Java多线程通信实例分享

原创深碍√TFBOYSˉ_ 2024-10-07 16:18 36阅读 0赞

Java多线程通信是开发者在处理并发任务时的重要手段，主要包括以下几种方式：

1. **wait()和notify()**：
   - wait()：当前线程进入等待状态，并释放已拥有的锁。
   - notify()：唤醒一个正在等待的线程。必须传入调用wait()方法的那同一个对象。

2. **synchronized同步块/方法**：
   - 在代码块或方法前加上`synchronized`关键字，可以控制同一时间只有一个线程执行该块或方法。

3. **信号量（Semaphore）**：
   - 信号量是一种多线程同步机制，用于控制在同一时刻进入临界区的线程数量。
   
实例分享（以生产者消费者模型为例）：

```java
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

private final LinkedList<Integer> buffer = new LinkedList<>();

public void produce() throws InterruptedException {
        while (true) {
            lock.lock();
            try {
                if (buffer.size() < 10) { // 充满限制
                    buffer.addLast(1);
                    condition.signalAll(); // 提醒等待的消费者和生产者
                    break;
                  }
                else {
                    System.out.println("Buffer overflow, discarding data.");
                    buffer.removeFirst();
                }
            } finally {
                lock.unlock();
            }
        }
    }

public void consume() throws InterruptedException {
        while (true) {
            lock.lock();
            try {
                if (buffer.isEmpty()) { // 空缓冲
                    condition.await(); // 等待填充数据
                    break;
                  }
                else {
                    System.out.println("Consuming data: " + buffer.removeFirst());
                }
            } finally {
                lock.unlock();
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
        ProducerConsumer producer = new ProducerConsumer();
        producer.produce(); // 生产数据
        producer.consume(); // 消费数据
    }
}
```

这个例子中，`Producer`负责生产数据，`Consumer`负责消费数据。两者通过条件判断和锁机制进行同步通信。