RedSpider项目深入解析：Java线程间通信的五大核心机制-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00432/article/details/148524223

RedSpider项目深入解析：Java线程间通信的五大核心机制

concurrent 这是RedSpider社区成员原创与维护的Java多线程系列文章。项目地址: https://gitcode.com/gh_mirrors/co/concurrent

引言

在并发编程的世界中，线程间的通信是构建复杂多线程应用的基础。本文将从技术专家的视角，系统性地剖析Java线程间通信的五大核心机制，帮助开发者深入理解并发编程的本质。

一、锁与同步机制

1.1 锁的本质理解

在Java中，锁是基于对象的同步机制。我们可以将锁理解为一种"通行证"——同一时间只能有一个线程持有这个通行证。当线程A获取锁后，其他尝试获取同一把锁的线程会进入阻塞状态，形成有序的访问序列。

1.2 同步的实际意义

同步的核心在于建立执行顺序的约束。以一个实际场景为例：假设我们有一个银行账户系统，多个线程同时进行存取款操作。如果没有同步机制，可能会导致余额计算错误。通过同步，我们可以确保同一时间只有一个线程能操作账户余额。

1.3 代码示例分析

public class BankAccount {
    private int balance = 1000;
    private final Object lock = new Object();
    
    public void withdraw(int amount) {
        synchronized(lock) {
            if(balance >= amount) {
                balance -= amount;
            }
        }
    }
}

在这个例子中，synchronized块确保了对balance变量的操作是原子性的。值得注意的是，我们专门创建了一个Object对象作为锁，而不是直接使用this，这样可以更精确地控制锁的范围。

二、等待/通知机制

2.1 机制原理

等待/通知机制是线程间协作的高级形式，它基于Object类的三个核心方法：

wait()：释放锁并进入等待状态
notify()：随机唤醒一个等待线程
notifyAll()：唤醒所有等待线程

2.2 生产者-消费者模式实现

public class MessageQueue {
    private final Queue<String> queue = new LinkedList<>();
    private final int maxSize;
    private final Object lock = new Object();
    
    public MessageQueue(int maxSize) {
        this.maxSize = maxSize;
    }
    
    public void put(String message) throws InterruptedException {
        synchronized(lock) {
            while(queue.size() == maxSize) {
                lock.wait();
            }
            queue.add(message);
            lock.notifyAll();
        }
    }
    
    public String take() throws InterruptedException {
        synchronized(lock) {
            while(queue.isEmpty()) {
                lock.wait();
            }
            String message = queue.poll();
            lock.notifyAll();
            return message;
        }
    }
}

关键点说明：

使用while循环而非if判断，防止虚假唤醒
优先使用notifyAll()而非notify()，避免信号丢失
wait()调用必须在同步块内

三、信号量机制

3.1 volatile关键字

volatile保证了变量的可见性，但不保证原子性。这意味着：

一个线程对volatile变量的修改对其他线程立即可见
复合操作(如i++)仍需同步

3.2 自定义信号量实现

public class CustomSemaphore {
    private volatile int signal = 0;
    
    public void increment() {
        synchronized(this) {
            signal++;
        }
    }
    
    public void decrement() {
        synchronized(this) {
            signal--;
        }
    }
    
    public int get() {
        return signal;
    }
}

3.3 实际应用场景

信号量特别适合资源池的实现，如数据库连接池。当所有连接都被占用时，新请求需要等待直到有连接被释放。

四、管道通信

4.1 管道的特点

基于I/O流实现
适用于线程间传递数据流
需要显式建立连接

4.2 使用注意事项

PipedWriter writer = new PipedWriter();
PipedReader reader = new PipedReader();
// 必须建立连接
writer.connect(reader);

管道通信适合处理流式数据，但性能不如共享内存方式高效。在需要高性能的场景下，应考虑其他通信方式。

五、其他通信机制

5.1 join方法详解

join()方法的本质是让当前线程等待目标线程终止。其实现原理实际上是调用了wait()方法：

public final synchronized void join(long millis) 
    throws InterruptedException {
    //...
    while (isAlive()) {
        wait(millis);
    }
    //...
}

5.2 sleep vs wait

关键区别表：

| 特性 | sleep | wait | |-----------|-------------------|-------------------| | 锁释放 | 不释放 | 释放 | | 调用位置 | 任意位置 | 同步块内 | | 唤醒方式 | 时间到期 | notify/notifyAll | | 方法所属 | Thread静态方法 | Object实例方法 |

5.3 ThreadLocal深入

ThreadLocal为每个线程创建独立的变量副本，典型应用场景包括：

数据库连接管理
用户会话信息存储
避免参数传递

public class UserContext {
    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
    
    public static void set(User user) {
        currentUser.set(user);
    }
    
    public static User get() {
        return currentUser.get();
    }
    
    public static void remove() {
        currentUser.remove();
    }
}

重要提示：使用ThreadLocal后必须及时remove()，否则可能导致内存泄漏，特别是在线程池场景下。