Java多线程编程：线程创建和同步

# 1. 引言 #### 1.1 什么是多线程编程多线程编程是指在一个程序中同时运行多个线程以完成不同的任务。线程是程序中执行的最小单位，多线程编程允许程序同时进行多个操作，提高了程序的并发性和效率。 #### 1.2 Java 多线程编程的重要性在Java中，多线程编程具有非常重要的意义。通过合理地使用多线程，程序可以更好地利用多核处理器的性能优势，提高程序的响应速度和吞吐量。同时，多线程也为复杂的任务提供了更好的解决方案，使得程序更加灵活和高效。接下来，我们将讨论Java多线程编程中线程的创建方式。 # 2. 线程的创建在Java中，有多种方式可以创建线程，每种方式都有其自身的优缺点。下面将介绍三种常用的线程创建方式。 ### 2.1 使用 Thread 类创建线程使用Thread类是最常见和最简单的创建线程的方式之一。可以通过继承Thread类，并重写其run()方法来创建线程。 ```java // 创建一个继承自Thread类的线程 class MyThread extends Thread { @Override public void run() { // 线程执行的逻辑代码 System.out.println("线程A正在运行"); } } public class ThreadCreationDemo { public static void main(String[] args) { // 创建线程对象 MyThread threadA = new MyThread(); // 启动线程 threadA.start(); System.out.println("主线程结束"); } } ``` 代码说明： - 自定义的线程类`MyThread`继承自Thread类，并重写其run()方法。 - 在main()方法中创建线程对象`threadA`，并调用start()方法启动线程。 - 主线程会继续执行后续代码，不会等待子线程的结束。 ### 2.2 实现 Runnable 接口创建线程实现Runnable接口是另一种常见的创建线程的方式。可以创建一个实现了Runnable接口的类，并将其作为参数传递给Thread类的构造方法。 ```java // 创建一个实现Runnable接口的类 class MyRunnable implements Runnable { @Override public void run() { // 线程执行的逻辑代码 System.out.println("线程B正在运行"); } } public class ThreadCreationDemo { public static void main(String[] args) { // 创建Runnable对象 MyRunnable runnable = new MyRunnable(); // 创建线程对象，并将Runnable对象作为参数传递 Thread threadB = new Thread(runnable); // 启动线程 threadB.start(); System.out.println("主线程结束"); } } ``` 代码说明： - 自定义的Runnable类`MyRunnable`实现了Runnable接口，并重写了run()方法。 - 在main()方法中创建了一个Runnable对象`runnable`。 - 创建线程对象`threadB`时，将Runnable对象`runnable`作为参数传递给Thread类的构造方法。 - 调用start()方法启动线程。 ### 2.3 Callable 和 Future 接口创建线程除了使用Thread类和Runnable接口，还可以使用Callable和Future接口创建线程。Callable接口类似于Runnable接口，但它可以返回执行结果。 ```java import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; // 创建一个实现Callable接口的类 class MyCallable implements Callable<String> { @Override public String call() throws Exception { // 线程执行的逻辑代码 return "线程C正在运行"; } } public class ThreadCreationDemo { public static void main(String[] args) { // 创建Callable对象 Callable<String> callable = new MyCallable(); // 创建FutureTask对象，将Callable对象作为参数传递 FutureTask<String> futureTask = new FutureTask<>(callable); // 创建线程对象，并将FutureTask对象作为参数传递 Thread threadC = new Thread(futureTask); // 启动线程 threadC.start(); try { // 获取线程的返回结果 String result = futureTask.get(); System.out.println(result); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } System.out.println("主线程结束"); } } ``` 代码说明： - 自定义的Callable类`MyCallable`实现了Callable接口，并重写了call()方法。在call()方法中定义线程的逻辑，并返回结果。 - 在main()方法中创建了一个Callable对象`callable`。 - 创建FutureTask对象`futureTask`时，将Callable对象作为参数传递给它的构造方法。 - 创建线程对象`threadC`时，将FutureTask对象`futureTask`作为参数传递给Thread类的构造方法。 - 调用start()方法启动线程。 - 使用futureTask.get()方法获取线程的返回结果。以上是使用Thread类、Runnable接口和Callable接口创建线程的三种常见方式。要根据具体的需求选择合适的方式来创建线程。 # 3. 线程的同步 #### 3.1 什么是线程同步在多线程编程中，线程同步是指多个线程按照一定的顺序执行，以确保数据的正确性和一致性。在并发编程中，如果多个线程同时访问共享资源，可能会导致数据混乱和错误，因此需要使用线程同步机制来协调多个线程的执行。 #### 3.2 synchronized 关键字在Java中，可以使用 `synchronized` 关键字来实现线程同步。通过在方法或代码块前添加 `synchronized` 关键字，可以确保在同一时间内只有一个线程执行该方法或代码块，从而避免多个线程同时访问共享资源。 ```java public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } } ``` #### 3.3 ReentrantLock 类除了使用 `synchronized` 关键字外，还可以使用 `ReentrantLock` 类来实现线程同步。`ReentrantLock` 提供了更灵活的锁定机制，可以实现公平锁、可重入锁等特性。 ```java import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private final ReentrantLock lock = new ReentrantLock(); private int count = 0; public void increment() { lock.lock(); try { count++; } finally { lock.unlock(); } } } ``` #### 3.4 ReadWriteLock 接口 `ReadWriteLock` 接口提供了读写锁的机制，允许多个线程同时读取共享资源，但在写操作时需要互斥。通过 `ReentrantReadWriteLock` 类可以实现该接口。 ```java import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockExample { private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); private int count = 0; public void increment() { rwLock.writeLock().lock(); try { count++; } finally { rwLock.writeLock().unlock(); } } public int getCount() { rwLock.readLock().lock(); try { return count; } finally { rwLock.readLock().unlock(); } } } ``` 在本章节中，我们介绍了线程同步的概念以及在Java中实现线程同步的几种方式，包括 `synchronized` 关键字、`ReentrantLock` 类和 `ReadWriteLock` 接口。这些机制可以帮助我们确保多线程环境下的数据安全性和一致性。 # 4. 线程的状态与生命周期 #### 4.1 线程的状态：新建、可运行、运行、阻塞、结束线程在其生命周期中会经历不同的状态，包括新建状态、可运行状态、运行状态、阻塞状态和结束状态。 - 新建状态：当创建一个线程对象并调用start()方法后，线程处于新建状态。此时，线程正在等待系统资源，如CPU资源。 - 可运行状态：当线程获得了系统资源，即CPU资源时，它从新建状态转为可运行状态。此时，线程可以被调度执行，并开始执行线程的run()方法。 - 运行状态：当线程处于可运行状态时，它正在执行run()方法中的代码。 - 阻塞状态：线程在以下情况下会进入阻塞状态： - 调用 sleep() 方法，线程会进入休眠状态； - 调用 wait() 方法，线程会等待其他线程的通知； - 调用 join() 方法，线程会等待被调用的线程执行完毕； - 试图获取一个被其他线程占用的锁。 - 结束状态：当线程完成了run()方法中的代码或者异常导致线程终止时，线程处于结束状态，此时它不再具有可运行的能力。 #### 4.2 线程的生命周期图解下图展示了线程的生命周期及状态之间的转换： ``` +-----------------+ +-------------------+ +-------------------+ | 新建状态 | | 可运行状态 | | 运行状态 | +-----------------+ +-------------------+ +-------------------+ | | | | +-----------------+ | | --->| 阻塞状态 |<-------+ | | +-----------------+ | | | | | | | V | | | +-----------------+ | | --- | 结束状态 | ------------------------------- +-----------------+ ``` 在生命周期中，线程会在不同的状态之间转换，具体转换的规则和条件取决于不同的场景和操作。了解线程的生命周期及状态转换是进行多线程编程的基础。以上是线程的状态与生命周期的介绍，通过理解线程的状态，可以更好地控制和管理多线程程序的执行流程。在接下来的章节中，我们将介绍线程间的通信，以及线程安全性的问题。 # 5. 线程间通信在多线程编程中，线程间通信是非常重要的，因为多个线程可能需要协调完成某项任务。在Java多线程编程中，线程间通信可以采用以下几种方式： #### 5.1 共享内存方式多个线程可以通过共享内存的方式进行通信，它们共享同一块内存区域，可以直接读写这块内存来实现通信。 ```java public class SharedMemoryExample { private static int sharedData = 0; public static void main(String[] args) { new Thread(() -> { for (int i = 0; i < 5; i++) { sharedData++; System.out.println("Thread 1: " + sharedData); } }).start(); new Thread(() -> { for (int i = 0; i < 5; i++) { sharedData--; System.out.println("Thread 2: " + sharedData); } }).start(); } } ``` 这里通过共享变量 sharedData 实现了线程之间的通信。 #### 5.2 使用 wait()、notify() 和 notifyAll() 方法在Java中，每个对象都有一个等待队列，线程可以调用对象的 wait() 方法进入等待状态，调用 notify() 或 notifyAll() 方法来唤醒等待队列中的线程。 ```java public class WaitNotifyExample { public static void main(String[] args) { Object lock = new Object(); Thread waitingThread = new Thread(() -> { synchronized (lock) { try { System.out.println("WaitingThread is waiting"); lock.wait(); System.out.println("WaitingThread is awake"); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread notifyingThread = new Thread(() -> { synchronized (lock) { System.out.println("NotifyingThread is notifying"); lock.notify(); } }); waitingThread.start(); notifyingThread.start(); } } ``` 在这个例子中，waitingThread 等待在 lock 对象上，notifyingThread 调用 lock.notify() 方法唤醒 waitingThread。 #### 5.3 使用 Condition 对象在Java的并发包中，Condition 对象提供了类似 wait()、notify() 和 notifyAll() 的功能，可以用来实现线程间的通信和协调。 ```java import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ConditionExample { private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); private boolean isDataReady = false; public void waitForData() throws InterruptedException { lock.lock(); try { while (!isDataReady) { condition.await(); } System.out.println("Data has been processed"); } finally { lock.unlock(); } } public void processData() { lock.lock(); try { System.out.println("Processing data"); isDataReady = true; condition.signal(); } finally { lock.unlock(); } } } ``` 在这个例子中，waitForData() 方法等待 isDataReady 变为 true，processData() 方法将 isDataReady 置为 true 并调用 condition.signal() 方法唤醒等待的线程。通过以上几种方式，多线程之间可以进行有效地通信和协调，实现更加复杂的任务处理和业务逻辑。 # 6. 线程安全性 ### 6.1 什么是线程安全性在多线程编程中，线程安全性是指多线程操作共享数据时，不会出现数据不一致或不正确的情况。如果多线程同时读写共享数据，可能会导致数据竞争和结果不确定的问题。因此，确保线程安全性非常重要。 ### 6.2 线程安全的数据结构与算法在Java中，线程安全的数据结构和算法是指在多线程环境下，能够正确处理并发访问的数据结构和算法。Java提供了许多线程安全的集合类和原子操作类，如`ConcurrentHashMap`、`CopyOnWriteArrayList`、`AtomicInteger`等，这些类都使用了各种同步机制来保证线程安全性。 ### 6.3 使用同步机制保证线程安全性为了保证线程安全性，可以使用各种同步机制来控制对共享数据的访问。常用的同步机制包括： - synchronized关键字：通过在方法或代码块前加上synchronized关键字，可以保证同一时间只有一个线程执行该方法或代码块，从而避免数据竞争。 - ReentrantLock类：通过使用显示锁来控制对共享数据的访问，可以灵活地控制加锁和释放锁的时机，同时还提供了更多的高级功能。 - ReadWriteLock接口：通过使用读写锁，可以实现对共享数据的读写操作的并发访问，从而提高程序的性能。下面是一个使用synchronized关键字的示例代码： ```java public class Counter { private int value = 0; public synchronized void increment() { value++; } public synchronized void decrement() { value--; } public synchronized int getValue() { return value; } } ``` 在上述代码中，使用synchronized关键字修饰了increment()、decrement()和getValue()方法，这样可以确保同时只有一个线程执行这些方法，从而保证了对value变量的操作的线程安全性。结论：线程安全性在多线程编程中非常重要，可以通过使用线程安全的数据结构和算法，以及各种同步机制来保证线程安全性。在具体实现过程中，需要根据具体的需求和场景选择合适的线程安全机制。