线程间通信的关键在于选择合适的机制以实现信息传递与协同操作，1. 共享变量配合synchronized或volatile可实现基础通信，但需注意线程安全；2. wait/notify/notifyall用于线程间的等待与唤醒，必须在synchronized块中使用；3. blockingqueue通过阻塞方式简化数据传递，适合生产者-消费者模型；4. countdownlatch用于一个或多个线程等待其他线程完成，计数器减至零时释放等待线程；5. cyclicbarrier用于多线程互相等待到达屏障点后继续执行，支持重复使用；6. exchanger适用于两个线程之间交换数据；7. 避免死锁需破坏占有且等待、循环等待等条件，可通过按序获取锁、使用定时锁等方式实现；8. volatile保证变量可见性和禁止指令重排序，但不保证原子性；9. 选择通信方式应根据场景综合考虑，如状态传递用volatile，阻塞等待用blockingqueue，线程同步用countdownlatch或cyclicbarrier，数据交换用exchanger，最终目标是确保线程安全、避免死锁并提升程序效率。
线程间的通信，简单来说，就是让不同的线程能够互相“说话”，传递信息，协同完成任务。Java提供了多种机制来实现这一点，但关键在于理解这些机制背后的原理，并根据实际场景选择最合适的方案。
解决方案
Java中实现线程间通信的方式有很多，常见的包括：
立即学习“Java免费学习笔记（深入）”；
-
共享变量： 这是最基础的方式。多个线程访问同一个变量，通过修改变量的值来传递信息。但需要注意线程安全问题，通常需要使用
synchronized
关键字或
volatile
关键字来保证变量的可见性和原子性。
public class SharedData { private boolean ready = false; public synchronized void setReady(boolean ready) { this.ready = ready; notifyAll(); // 通知所有等待的线程 } public synchronized boolean isReady() throws InterruptedException { while (!ready) { wait(); // 等待ready变为true } return ready; } } // 线程A public class ThreadA extends Thread { private SharedData data; public ThreadA(SharedData data) { this.data = data; } @Override public void run() { // 执行一些操作后 data.setReady(true); System.out.println("Thread A: Data is ready!"); } } // 线程B public class ThreadB extends Thread { private SharedData data; public ThreadB(SharedData data) { this.data = data; } @Override public void run() { try { boolean ready = data.isReady(); System.out.println("Thread B: Data is ready? " + ready); } catch (InterruptedException e) { e.printStackTrace(); } } } public class Main { public static void main(String[] args) { SharedData data = new SharedData(); ThreadA threadA = new ThreadA(data); ThreadB threadB = new ThreadB(data); threadB.start(); // 先启动ThreadB，让它等待 threadA.start(); } }
这里使用了
synchronized
和
wait/notifyAll
机制。
wait()
使线程进入等待状态，直到被
notifyAll()
唤醒。
-
wait()
/
notify()
/
notifyAll()
： 这些方法是
类提供的，必须在
synchronized
代码块中使用。
wait()
让线程进入等待状态，
notify()
唤醒一个等待的线程，
notifyAll()
唤醒所有等待的线程。
-
BlockingQueue
： 这是一个阻塞队列，线程可以从队列中获取数据，如果队列为空，线程会阻塞等待。另一个线程可以向队列中放入数据，唤醒等待的线程。
import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class BlockingQueueExample { private static BlockingQueue<String> queue = new LinkedBlockingQueue<>(); public static void main(String[] args) { new Thread(() -> { try { System.out.println("Producer: Producing message 1"); queue.put("Message 1"); System.out.println("Producer: Producing message 2"); queue.put("Message 2"); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); new Thread(() -> { try { Thread.sleep(100); // 模拟消费者慢一点 System.out.println("Consumer: Consuming " + queue.take()); System.out.println("Consumer: Consuming " + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); } }BlockingQueue
简化了线程间的同步和数据传递，避免了手动使用
wait/notify
的复杂性。
-
CountDownLatch
： 允许一个或多个线程等待其他线程完成操作。可以理解为一个计数器，当计数器变为0时，等待的线程被释放。
import java.util.concurrent.CountDownLatch; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { CountDownLatch latch = new CountDownLatch(3); // 计数器初始值为3 new Thread(() -> { System.out.println("Thread 1: Doing some work..."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } latch.countDown(); // 计数器减1 System.out.println("Thread 1: Work finished, countdown!"); }).start(); new Thread(() -> { System.out.println("Thread 2: Doing some work..."); try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } latch.countDown(); // 计数器减1 System.out.println("Thread 2: Work finished, countdown!"); }).start(); new Thread(() -> { System.out.println("Thread 3: Doing some work..."); try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); } latch.countDown(); // 计数器减1 System.out.println("Thread 3: Work finished, countdown!"); }).start(); latch.await(); // 主线程等待，直到计数器变为0 System.out.println("Main thread: All threads finished their work!"); } }CountDownLatch
常用于协调多个线程的执行，例如等待所有子任务完成后再执行主任务。
-
CyclicBarrier
： 允许一组线程互相等待，直到所有线程都到达某个屏障点，然后这些线程才能继续执行。与
CountDownLatch
不同，
CyclicBarrier
可以重用。
import java.util.concurrent.CyclicBarrier; public class CyclicBarrierExample { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(3, () -> { System.out.println("All threads have reached the barrier. Executing barrier action!"); }); for (int i = 0; i < 3; i++) { final int threadId = i; new Thread(() -> { System.out.println("Thread " + threadId + ": Starting..."); try { Thread.sleep((long) (Math.random() * 3000)); // 模拟不同的工作时间 System.out.println("Thread " + threadId + ": Reached the barrier, waiting for others..."); barrier.await(); // 等待其他线程到达屏障 System.out.println("Thread " + threadId + ": Continuing after the barrier..."); } catch (Exception e) { e.printStackTrace(); } }).start(); } } }CyclicBarrier
适合于多个线程需要同步执行的情况，例如并行计算的每个阶段都需要等待所有线程完成。
-
Exchanger
： 允许两个线程交换数据。每个线程将自己的数据传递给对方，并接收对方的数据。
import java.util.concurrent.Exchanger; public class ExchangerExample { public static void main(String[] args) { Exchanger<String> exchanger = new Exchanger<>(); new Thread(() -> { String data = "Data from Thread 1"; try { System.out.println("Thread 1: Exchanging data: " + data); String receivedData = exchanger.exchange(data); System.out.println("Thread 1: Received data: " + receivedData); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); new Thread(() -> { String data = "Data from Thread 2"; try { System.out.println("Thread 2: Exchanging data: " + data); String receivedData = exchanger.exchange(data); System.out.println("Thread 2: Received data: " + receivedData); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); } }Exchanger
适用于两个线程需要频繁交换数据的场景。
如何避免死锁？
死锁是多线程编程中常见的问题，指的是两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行。避免死锁的关键在于破坏死锁产生的条件：
- 互斥条件： 资源必须是独占的，不能被多个线程同时访问。这个条件通常无法避免，因为很多资源本身就是互斥的。
- 占有且等待条件： 线程必须占有一个资源，并且等待获取另一个资源。
- 不可剥夺条件： 线程已经获取的资源不能被强制剥夺。
- 循环等待条件： 存在一个线程的循环等待链，例如线程A等待线程B释放资源，线程B等待线程C释放资源，线程C等待线程A释放资源。
因此，避免死锁的常见策略包括：
- 避免嵌套锁： 尽量减少线程同时持有多个锁的情况。如果必须持有多个锁，确保以相同的顺序获取锁。
- 使用定时锁： 使用
tryLock()
方法尝试获取锁，如果超过一定时间仍未获取到锁，则放弃并释放已持有的锁。
- 死锁检测： 使用专门的工具或算法来检测死锁，并在死锁发生时采取措施，例如回滚事务。
volatile
关键字的作用是什么？
volatile
关键字用于保证变量的可见性和禁止指令重排序。
- 可见性： 当一个线程修改了
volatile
变量的值，其他线程能够立即看到修改后的值。这是通过强制线程每次使用变量时都从主内存中读取，而不是从线程的本地缓存中读取来实现的。
- 禁止指令重排序： 编译器和处理器可能会对指令进行重排序以提高性能。
volatile
关键字可以防止这种重排序，保证代码按照程序员的意图执行。
但是，
volatile
关键字不能保证原子性。对于复合操作（例如
i++
），仍然需要使用
synchronized
或
AtomicInteger
等机制来保证线程安全。
如何选择合适的线程通信方式？
选择合适的线程通信方式取决于具体的应用场景。
- 如果只是简单的状态传递，可以使用共享变量和
volatile
关键字。
- 如果需要阻塞等待，可以使用
wait/notify
或
BlockingQueue
。
BlockingQueue
更易于使用，且线程安全。
- 如果需要协调多个线程的执行，可以使用
CountDownLatch
或
CyclicBarrier
。
- 如果需要两个线程交换数据，可以使用
Exchanger
。
总之，理解各种线程通信机制的原理和适用场景，并根据实际需求选择最合适的方案，是编写高效、可靠的多线程程序的关键。
