Java 多线程：并发编程分步指南
多线程是 Java 中一个强大的概念，它允许我们在单个进程中同时运行多个线程。对于开发响应迅速且高效的应用程序来说，这一点至关重要，尤其是在当今的多核处理器环境中。在这份全面的指南中，我们将深入探讨多线程，涵盖理论和实际实现，使我们精通 Java 编程的这一重要方面。
什么是多线程？
多线程是一种编程概念，允许单个进程同时执行多个线程。线程是进程中的轻量级子进程，它们共享相同的内存空间，但可以独立运行。每个线程代表一个单独的控制流，使得在单个程序中同时执行多个任务成为可能。
重点：
- 线程是进程的较小单元，共享相同的内存空间。
- 线程可以被视为独立的、并行的执行路径。
- 多线程能够高效利用多核处理器。
为什么使用多线程？
多线程具有多个优势，使其成为软件开发中的一个有价值的工具：
- 提高响应性：多线程允许应用程序在执行资源密集型任务时仍能对用户输入保持响应。例如，一个文本编辑器可以在后台执行拼写检查的同时继续响应用户操作。
- 增强性能：多线程程序可以利用多核处理器，从而带来更好的性能。任务可以在多个线程之间分配，加速计算。
- 资源共享：线程可以在同一进程内共享数据和资源，这可以导致更高效的内存使用。在内存密集型应用程序中，这一点可能至关重要。
- 并发：多线程实现任务的并发执行，使得同时管理多个任务更加容易。例如，一个 Web 服务器可以使用线程同时处理多个客户端请求。
术语和概念
为了理解多线程，掌握以下关键概念至关重要：
- 线程：线程是进程内最小的执行单元。单个进程中可以存在多个线程，并且它们共享相同的内存空间。
- 进程：进程是在其内存空间中运行的独立程序。它可以由一个或多个线程组成。
- 并发：并发是指在重叠的时间间隔内执行多个线程。它允许任务看起来像是同时执行。
- 并行：并行涉及多个线程或进程的实际同时执行，通常在多核处理器上。它实现真正的同时执行。
- 竞争条件：当两个或多个线程同时访问共享数据时，就会发生竞争条件，最终结果取决于执行的时间和顺序。它可能导致不可预测的行为和错误。
- 同步：同步是一种用于协调和控制对共享资源的访问的机制。它通过只允许一个线程在同一时间访问资源来防止竞争条件。
- 死锁：死锁是一种两个或多个线程因为彼此等待对方释放资源而无法继续执行的情况。它可能导致系统冻结。
在 Java 中创建线程
- 扩展
Thread类 - 实现
Runnable接口
在 Java 中，我们可以通过两种主要方式创建线程：通过扩展Thread类或实现Runnable接口。这两种方法都允许我们定义在新线程中运行的代码。
扩展Thread类：
要通过扩展Thread类创建线程，我们需要创建一个新类，该类继承自Thread并覆盖run()方法。run()方法包含当线程启动时将执行的代码。以下是一个例子：
class MyThread extends Thread {
public void run() {
// 新线程中要执行的代码
for (int i = 1; i <= 5; i++) {
System.out.println("Thread " + Thread.currentThread().getId() + ": Count " + i);
}
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start(); // 启动第一个线程
thread2.start(); // 启动第二个线程
}
}在这个例子中，我们通过扩展Thread类创建了MyThread类。run()方法包含了新线程中要执行的代码。我们创建了两个MyThread的实例，并使用start()方法启动它们。
实现Runnable接口：
另一种通常更灵活的创建线程的方法是实现Runnable接口。这种方法允许我们将线程的行为与其结构分离，使得更容易重用和扩展。以下是一个例子：
class MyRunnable implements Runnable {
public void run() {
// 新线程中要执行的代码
for (int i = 1; i <= 5; i++) {
System.out.println("Thread " + Thread.currentThread().getId() + ": Count " + i);
}
}
}
public class ThreadExample {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.start(); // 启动第一个线程
thread2.start(); // 启动第二个线程
}
}在这个例子中，我们创建了一个实现Runnable接口的MyRunnable类。run()方法包含了新线程中要执行的代码。我们创建了两个Thread实例，将MyRunnable实例作为构造函数参数传递。然后，我们启动这两个线程。
线程生命周期：
Java 中的线程在其生命周期中经历各种状态：
- 新建：当一个线程被创建但尚未启动时。
- 可运行：线程已准备好运行，正在等待轮到它执行。
- 运行：线程正在积极执行其代码。
- 阻塞/等待：线程暂时不活动，通常是由于等待资源或事件。
- 终止：线程已完成执行并已终止。
理解线程生命周期对于在多线程应用程序中进行正确的线程管理和同步至关重要。
使用多个线程
在使用多个线程时，我们需要注意各种挑战和概念，包括线程干扰、死锁、线程优先级和线程组。
线程干扰：
当多个线程同时访问共享数据时，就会发生线程干扰，导致意外和不正确的结果。为了避免线程干扰，我们可以使用同步机制，如synchronized块或方法，以确保一次只有一个线程访问共享数据。这里有一个简单的例子说明线程干扰：
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
public class ThreadInterferenceExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Final Count: " + counter.getCount());
}
}在这个例子中，两个线程（thread1和thread2）同时增加一个共享计数器。为了防止干扰，我们使用同步方法来增加和获取计数器的值。
死锁和解决方案：
当两个或多个线程因为彼此等待对方释放资源而无法继续执行时，就会发生死锁。死锁可能很难诊断和修复。防止死锁的策略包括使用正确的锁定顺序、超时和死锁检测算法。这里是一个潜在死锁情况的高级示例：
class Resource {
public synchronized void method1(Resource other) {
// 做一些事情
other.method2(this);
// 做一些事情
}
public synchronized void method2(Resource other) {
// 做一些事情
other.method1(this);
// 做一些事情
}
}
public class DeadlockExample {
public static void main(String[] args) {
Resource resource1 = new Resource();
Resource resource2 = new Resource();
Thread thread1 = new Thread(() -> resource1.method1(resource2));
Thread thread2 = new Thread(() -> resource2.method1(resource1));
thread1.start();
thread2.start();
}
}在这个例子中，thread1调用resource1的method1，而thread2调用resource2的method1。两个方法随后都尝试获取另一个资源的锁，导致潜在的死锁情况。
线程优先级和组：
Java 允许我们设置线程优先级，以影响 Java 虚拟机（JVM）的线程调度程序执行线程的顺序。具有较高优先级的线程会被优先考虑，尽管谨慎使用线程优先级很重要，因为它们在不同的 JVM 实现中可能表现不一致。此外，我们可以将线程分组以进行更好的管理和控制。
Thread thread1 = new Thread(() -> {
// 线程 1 的逻辑
});
Thread thread2 = new Thread(() -> {
// 线程 2 的逻辑
});
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
ThreadGroup group = new ThreadGroup("MyThreadGroup");
Thread thread3 = new Thread(group, () -> {
// 线程 3 的逻辑
});在这个例子中，我们为thread1和thread2设置线程优先级，并为thread3创建一个名为“MyThreadGroup”的线程组。线程优先级范围从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。
理解并有效地管理线程干扰、死锁、线程优先级和线程组在 Java 中使用多个线程时至关重要。
Java 的并发实用工具
Java 提供了一组强大的并发实用工具，简化了多线程应用程序的开发。Java 并发实用工具的三个基本组件是执行器框架、线程池以及Callable和Future。
执行器框架：
执行器框架是一个用于在多线程环境中异步管理任务执行的抽象层。它将任务提交与任务执行解耦，使我们能够专注于需要完成的任务，而不是如何执行它。
以下是如何使用执行器框架执行任务的示例：
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class ExecutorExample {
public static void main(String[] args) {
Executor executor = Executors.newSingleThreadExecutor();
Runnable task = () -> {
System.out.println("Task is executing...");
};
executor.execute(task);
}
}在这个例子中，我们使用Executors.newSingleThreadExecutor()创建一个执行器，它创建一个单线程执行器。然后，我们提交一个Runnable任务以异步执行。
线程池：
线程池是一种用于管理和重用固定数量的线程来执行任务的机制。与为每个任务创建一个新线程相比，它们提供了更好的性能，因为减少了线程创建和销毁的开销。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Runnable task1 = () -> {
System.out.println("Task 1 is executing...");
};
Runnable task2 = () -> {
System.out.println("Task 2 is executing...");
};
executorService.submit(task1);
executorService.submit(task2);
executorService.shutdown();
}
}在这个例子中，我们创建一个固定大小的线程池，有两个线程，并提交两个任务执行。当不再需要时，调用shutdown方法优雅地关闭线程池。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Runnable task1 = () -> {
System.out.println("Task 1 is executing...");
};
Runnable task2 = () -> {
System.out.println("Task 2 is executing...");
};
executorService.submit(task1);
executorService.submit(task2);
executorService.shutdown();
}
}Callable接口类似于Runnable，但它可以返回结果或抛出异常。Future接口表示异步计算的结果，并提供方法来检索结果或处理异常。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableAndFutureExample {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newSingleThreadExecutor();
Callable<Integer> task = () -> {
Thread.sleep(2000);
return 42;
};
Future<Integer> future = executorService.submit(task);
System.out.println("Waiting for the result...");
Integer result = future.get();
System.out.println("Result: " + result);
executorService.shutdown();
}
}这些 Java 并发实用工具为我们的应用程序提供了一种强大而高效的方式来管理多线程任务、线程池和异步计算。
高级多线程
在高级多线程中，我们更深入地探讨管理线程、处理同步以及利用 Java 中的高级并发特性的复杂性。
守护线程：
守护线程是在 Java 应用程序后台运行的后台线程。它们通常用于非关键任务，并且在主程序完成执行时不会阻止应用程序退出。
Thread daemonThread = new Thread(() -> {
while (true) {
// 执行后台任务
}
});
daemonThread.setDaemon(true); // 设置为守护线程
daemonThread.start();
线程局部变量：
线程局部变量是每个线程本地的变量。它们允许我们存储特定于特定线程的数据，确保每个线程都有自己独立的变量副本。
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalExample {
public static void main(String[] args) {
ThreadLocal<AtomicInteger> threadLocal = ThreadLocal.withInitial(AtomicInteger::new);
Runnable task = () -> {
AtomicInteger value = threadLocal.get();
value.incrementAndGet();
System.out.println("Thread " + Thread.currentThread().getName() + " value: " + value);
threadLocal.remove();
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
}
}
线程状态（等待、定时等待、阻塞）：
线程可以处于不同的状态，包括等待、定时等待和阻塞。这些状态代表线程正在等待资源或条件改变的各种情况。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadStateExample {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Runnable waitingTask = () -> {
lock.lock();
try {
System.out.println("Thread waiting...");
condition.await();
System.out.println("Thread resumed.");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
};
Runnable signalingTask = () -> {
lock.lock();
try {
System.out.println("Signaling thread...");
condition.signal();
} finally {
lock.unlock();
}
};
Thread waitingThread = new Thread(waitingTask);
Thread signalingThread = new Thread(signalingTask);
waitingThread.start();
signalingThread.start();
}
}
线程间通信：
线程间通信允许线程协调并交换信息。这包括使用wait、notify和notifyAll方法来同步线程。
class SharedResource {
private boolean flag = false;
public synchronized void waitForSignal() throws InterruptedException {
while (!flag) {
wait();
}
}
public synchronized void setSignal() {
flag = true;
notifyAll();
}
}
public class ThreadCommunicationExample {
public static void main(String[] args) {
SharedResource sharedResource = new SharedResource();
Thread waitingThread = new Thread(() -> {
try {
sharedResource.waitForSignal();
System.out.println("Waiting thread received signal.");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
Thread signalingThread = new Thread(() -> {
sharedResource.setSignal();
System.out.println("Signaling thread sent signal.");
});
waitingThread.start();
signalingThread.start();
}
}
并发集合：
并发集合是线程安全的数据结构，允许多个线程同时访问和修改它们，而不会导致数据损坏或同步问题。一些例子包括ConcurrentHashMap、ConcurrentLinkedQueue和CopyOnWriteArrayList。
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
public class ConcurrentCollectionsExample {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("key1", 1);
concurrentHashMap.put("key2", 2);
System.out.println("ConcurrentHashMap: " + concurrentHashMap);
ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
concurrentLinkedQueue.add("item1");
concurrentLinkedQueue.add("item2");
System.out.println("ConcurrentLinkedQueue: " + concurrentLinkedQueue);
CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
copyOnWriteArrayList.add("element1");
copyOnWriteArrayList.add("element2");
System.out.println("CopyOnWriteArrayList: " + copyOnWriteArrayList);
}
}
线程安全和最佳实践：
在多线程应用程序中确保线程安全至关重要。本节涵盖最佳实践，如使用不可变对象、原子类以及避免字符串驻留，以编写健壮且线程安全的代码。
import java.util.concurrent.atomic.AtomicInteger;
class ImmutableObject {
private final int value;
public ImmutableObject(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
public class ThreadSafetyBestPracticesExample {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(0);
ImmutableObject immutableObject = new ImmutableObject(10);
Runnable incrementTask = () -> {
atomicInteger.incrementAndGet();
System.out.println("Atomic integer value: " + atomicInteger.get());
};
Runnable readImmutableTask = () -> {
System.out.println("Immutable object value: " + immutableObject.getValue());
};
Thread thread1 = new Thread(incrementTask);
Thread thread2 = new Thread(readImmutableTask);
thread1.start();
thread2.start();
}
}
Java 中的并行：
并行涉及并发执行任务以提高性能。Java 在 Java 8 中提供了并行流和CompletableFuture用于异步编程等功能。
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
public class JavaParallelismExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNumbers = numbers.parallelStream()
.map(n -> n * n)
.collect(Collectors.toList());
System.out.println("Squared numbers using parallel stream: " + squaredNumbers);
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
System.out.println("Asynchronous task using CompletableFuture.");
});
future.join();
}
}
真实世界的多线程：
本节深入探讨多线程的实际应用，包括实现 Web 服务器以及在游戏开发中使用多线程。
// Web 服务器示例（简化版）
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SimpleWebServerExample {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Web server started on port 8080.");
while (true) {
Socket clientSocket = serverSocket.accept();
handleRequest(clientSocket);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleRequest(Socket clientSocket) {
try {
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
out.println("HTTP/1.1 200 OK");
out.println("Content-Type: text/html");
out.println();
out.println("<html><body>Hello from simple web server!</body></html>");
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
这些高级多线程主题为开发人员提供了构建高效、并发和可扩展的 Java 应用程序所需的知识和技能。每个主题都附有示例以说明概念和技术。
若你想提升Java技能，可关注我们的Java培训课程。