线程协作全攻略：5大核心机制破解并发编程难题

引言：从生产者-消费者问题看线程协作本质

在电商订单处理系统中，每秒需处理数万个订单的创建与物流信息更新。当生产者线程与消费者线程因处理速度差异导致系统吞吐量骤降时，如何实现高效协作成为关键。本文将揭秘Java线程协作的五大核心机制，并通过工业级案例展示其应用场景。

一、基础同步机制

1.1 等待通知机制（Wait/Notify）

// 经典生产者实现
public synchronized void produce() throws InterruptedException {
    while (queue.isFull()) {
        wait(); // 释放锁进入WAITING状态
    }
    queue.add(item);
    notifyAll(); // 唤醒所有等待线程
}

// 消费者实现
public synchronized void consume() throws InterruptedException {
    while (queue.isEmpty()) {
        wait();
    }
    queue.remove();
    notifyAll();
}

关键点：

• wait()释放对象锁
• notify()随机唤醒单个线程
• 必须配合synchronized使用

1.2 Condition条件变量

Lock lock = new ReentrantLock();
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

public void produce() {
    lock.lock();
    try {
        while (queue.isFull()) {
            notFull.await(); // 进入条件等待队列
        }
        queue.add(item);
        notEmpty.signal();
    } finally {
        lock.unlock();
    }
}

对比优势：

• 支持多个等待队列
• 可设置超时时间
• 灵活控制唤醒对象

二、高级协作工具

2.1 倒计时门闩（CountDownLatch）

// 多模块初始化场景
CountDownLatch latch = new CountDownLatch(3);

module1InitThread.start(); // 完成后执行latch.countDown()
module2InitThread.start();
module3InitThread.start();

latch.await(); // 主线程等待初始化完成
startSystem();

2.2 循环屏障（CyclicBarrier）

// 多阶段数据处理
CyclicBarrier barrier = new CyclicBarrier(4, () -> {
    System.out.println("本阶段数据处理完成");
});

dataThread1.start(); // 调用barrier.await()
dataThread2.start();
dataThread3.start();
dataThread4.start();

2.3 信号量（Semaphore）

// 连接池流量控制
Semaphore semaphore = new Semaphore(10);

public Connection getConnection() throws InterruptedException {
    semaphore.acquire(); // 获取许可证
    return pool.getAvailableConnection();
}

public void releaseConnection(Connection conn) {
    pool.returnConnection(conn);
    semaphore.release(); // 释放许可证
}

三、线程安全数据交换

3.1 阻塞队列（BlockingQueue）

队列类型	特性说明	适用场景
ArrayBlockingQueue	数组实现、固定容量	精确流量控制
LinkedBlockingQueue	链表实现、可选容量限制	高吞吐量任务队列
SynchronousQueue	直接传递模式、零容量	手递手数据交换

// 日志异步处理系统
BlockingQueue<Log> queue = new ArrayBlockingQueue<>(1000);

// 生产者线程
public void log(Log log) throws InterruptedException {
    queue.put(log); // 队列满时阻塞
}

// 消费者线程
public void run() {
    while (running) {
        Log log = queue.take(); // 队列空时阻塞
        saveToDatabase(log);
    }
}

四、分布式协作扩展

4.1 分布式锁（Redis实现）

public boolean tryLock(String key, int expireTime) {
    return redis.setnx(key, "locked") == 1 
        && redis.expire(key, expireTime);
}

public void processWithLock() {
    if (tryLock("order_lock", 30)) {
        try {
            // 执行核心业务逻辑
        } finally {
            redis.del("order_lock");
        }
    }
}

4.2 消息队列解耦

// RabbitMQ生产者
public void sendTask(Task task) {
    rabbitTemplate.convertAndSend("taskExchange", "task.routingKey", task);
}

// 消费者集群
@RabbitListener(queues = "taskQueue")
public void handleTask(Task task) {
    executorService.submit(() -> processTask(task));
}

五、最佳实践与避坑指南

5.1 协作模式选择矩阵

场景特征	推荐方案	优势点
一对多通知	CountDownLatch	简单高效
多阶段协同	CyclicBarrier	支持重复使用
资源池化管理	Semaphore	精准控制并发数
生产消费解耦	BlockingQueue	自带流量削峰

5.2 常见问题解决方案

问题1：线程饥饿

• 使用公平锁策略
• 设置等待超时时间
• 引入优先级队列

问题2：死锁检测

// 使用jstack检测死锁
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] threadIds = bean.findDeadlockedThreads();
if (threadIds != null) {
    ThreadInfo[] infos = bean.getThreadInfo(threadIds);
    // 打印死锁信息
}

问题3：虚假唤醒

• 始终在循环中检查条件
• 使用Object.wait(timeout)
• 结合条件变量精确唤醒

结语：协作模式的选择哲学

线程协作如同交响乐团的配合，不同的场景需要不同的指挥策略。理解各工具类底层原理，根据业务特征选择最优方案，才能构建出高吞吐、低延迟的并发系统。

讨论话题：在微服务架构下，如何实现跨JVM的线程协作？分布式锁与消息队列方案如何取舍？欢迎分享你的实战经验！