面试官：线程间有几种通信方式？

大家好，欢迎来到IT知识分享网。

#多线程# #java多线程#

在Java中，有几种常见的线程间通信方式：

1. 共享内存：在Java中，可以使用共享变量来实现线程之间的共享内存通信。多个线程可以访问和修改相同的共享变量。为了保证线程安全，可以使用关键字 synchronized 或 volatile 来保证变量的可见性或互斥访问。

public class SharedMemoryExample { private int sharedVariable; public synchronized void setSharedVariable(int value) { this.sharedVariable = value; } public synchronized int getSharedVariable() { return this.sharedVariable; } } 

2. Wait/Notify机制：通过 wait() 和 notify() 方法，线程可以实现等待和唤醒的机制实现线程间通信。

public class WaitNotifyExample { private boolean ready = false; public synchronized void waitForSignal() throws InterruptedException { while (!ready) { wait(); } // 执行相应操作 } public synchronized void signal() { ready = true; notify(); } } 

3. Condition条件变量：Java中的 Condition 接口提供了类似于 wait() 和 notify() 的功能，可以用于线程间的等待和唤醒操作。

import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ConditionVariableExample { private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); private boolean ready = false; public void waitForSignal() throws InterruptedException { lock.lock(); try { while (!ready) { condition.await(); } // 执行相应操作 } finally { lock.unlock(); } } public void signal() { lock.lock(); try { ready = true; condition.signal(); } finally { lock.unlock(); } } } 

4. BlockingQueue阻塞队列：Java中的 BlockingQueue 实现了线程安全的队列，并提供了阻塞操作。线程可以通过 put() 方法插入元素，并在队列满时阻塞，或者使用 take() 方法取出元素，在队列为空时阻塞。

import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class BlockingQueueExample { private BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); public void producer(int value) throws InterruptedException { queue.put(value); } public void consumer() throws InterruptedException { int value = queue.take(); // 处理元素的操作 } } 

5. 信号量：通过使用Java中的Semaphore、CountDownLatch、CyclicBarrier等类来实现线程间同步和通信。信号量是一种线程间通信的方式，用于控制同时访问某个资源或临界区的线程数量。下面是一个基于信号量的线程间通信的例子：

import java.util.concurrent.Semaphore; public class SemaphoreExample { // 信号量的初始计数为1 private Semaphore semaphore = new Semaphore(1); public void accessResource() { try { semaphore.acquire(); // 获取信号量，计数减1 // 访问共享资源的操作 // ... } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); // 释放信号量，计数加1 } } } 

在上面的示例中，Semaphore 的初始计数为1，表示只允许一个线程同时访问共享资源。在 accessResource() 方法中，线程首先调用 acquire() 方法获取信号量，如果当前计数值为0，则线程会被阻塞，等待其他线程释放信号量。当线程执行完共享资源的操作后，调用 release() 方法释放信号量，计数值加1，其他等待的线程可以继续执行。

通过信号量，可以控制同时访问共享资源的线程数量，有效地进行线程间的协调和同步。在实际应用中，可以根据具体情况，设置不同的初始计数值，以满足不同的需求。

这些都是Java中常用的几种线程间通信方式，可以根据具体的场景和需求选择适合的方式来实现线程间的通信。

引用网络图片