#多线程# #java多线程#

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

共享内存：在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;    }}

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();    }}

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();        }    }}

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();        // 处理元素的操作    }}

信号量：通过使用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中常用的几种线程间通信方式，可以根据具体的场景和需求选择适合的方式来实现线程间的通信。

引用网络图片