Java Condition：深入理解与高效应用

简介

在Java多线程编程中，Condition是一个强大的工具，用于线程间的协调与通信。它提供了比传统的Object的wait()、notify()和notifyAll()方法更灵活、更细粒度的控制。理解并掌握Condition的使用，对于编写高效、可靠的多线程应用程序至关重要。本文将详细介绍Condition的基础概念、使用方法、常见实践以及最佳实践。

目录

1. 基础概念
2. 使用方法
   • 创建Condition
   • 等待信号
   • 发送信号
3. 常见实践
   • 生产者 - 消费者模型
   • 线程间同步
4. 最佳实践
   • 资源管理
   • 异常处理
5. 小结
6. 参考资料

基础概念

Condition是在java.util.concurrent.locks包中定义的一个接口。它与Lock接口紧密相关，Lock提供了更灵活的锁机制，而Condition则用于在锁的基础上实现线程间的复杂同步和通信。

一个Lock可以创建多个Condition实例，每个Condition实例都可以被看作是一个独立的线程等待集合。这意味着可以根据不同的条件，让不同的线程在不同的Condition上等待，而不是像传统的Object的wait()和notify()那样，所有线程都在同一个对象的监视器上等待和通知。

使用方法

创建Condition

要使用Condition，首先需要创建一个Lock实例，然后通过Lock的newCondition()方法来创建Condition实例。

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

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

    // 其他代码...
}

等待信号

线程可以通过调用Condition的await()方法在该Condition上等待。调用await()方法时，线程会释放持有的锁，进入等待状态，直到其他线程在同一个Condition上调用signal()或signalAll()方法。

public void waitOnCondition() {
    lock.lock();
    try {
        System.out.println("线程 " + Thread.currentThread().getName() + " 开始等待");
        condition.await();
        System.out.println("线程 " + Thread.currentThread().getName() + " 被唤醒");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        lock.unlock();
    }
}

发送信号

• signal()方法：唤醒在此Condition等待集中的单个线程。如果有多个线程在等待，选择是任意的。
• signalAll()方法：唤醒在此Condition等待集中的所有线程。

public void signalCondition() {
    lock.lock();
    try {
        System.out.println("线程 " + Thread.currentThread().getName() + " 发送信号");
        condition.signal();
    } finally {
        lock.unlock();
    }
}

public void signalAllCondition() {
    lock.lock();
    try {
        System.out.println("线程 " + Thread.currentThread().getName() + " 发送所有信号");
        condition.signalAll();
    } finally {
        lock.unlock();
    }
}

常见实践

生产者 - 消费者模型

在生产者 - 消费者模型中，Condition可以很好地实现生产者和消费者之间的同步。生产者在缓冲区满时等待，消费者在缓冲区空时等待。

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

public class ProducerConsumerExample {
    private static final int MAX_SIZE = 5;
    private final Queue<Integer> queue = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public void produce(int item) {
        lock.lock();
        try {
            while (queue.size() == MAX_SIZE) {
                System.out.println("缓冲区已满，生产者等待");
                notFull.await();
            }
            queue.add(item);
            System.out.println("生产者生产: " + item);
            notEmpty.signal();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    public int consume() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                System.out.println("缓冲区为空，消费者等待");
                notEmpty.await();
            }
            int item = queue.poll();
            System.out.println("消费者消费: " + item);
            notFull.signal();
            return item;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
        return -1;
    }
}

线程间同步

Condition还可以用于更复杂的线程间同步场景，例如多个线程需要按照特定顺序执行。

public class ThreadSyncExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private boolean flag = false;

    public void thread1() {
        lock.lock();
        try {
            while (!flag) {
                System.out.println("线程1等待");
                condition1.await();
            }
            System.out.println("线程1执行");
            condition2.signal();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    public void thread2() {
        lock.lock();
        try {
            flag = true;
            System.out.println("线程2设置标志并唤醒线程1");
            condition1.signal();
            condition2.await();
            System.out.println("线程2执行");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }
}

最佳实践

资源管理

在使用Condition时，要注意资源的合理管理。确保在等待和唤醒线程时，相关的资源（如缓冲区）状态正确。例如，在生产者 - 消费者模型中，要确保缓冲区的大小限制和数据的正确处理。

异常处理

在调用await()方法时，可能会抛出InterruptedException异常。要正确处理该异常，通常是重新设置中断状态，以确保线程的中断状态能被正确传播。

try {
    condition.await();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

避免死锁

死锁是多线程编程中常见的问题。使用Condition时，要确保线程不会因为互相等待对方释放资源而陷入死锁。例如，在多个线程之间传递信号时，要确保信号的发送和接收逻辑正确。

小结

Condition为Java多线程编程提供了强大的同步和通信机制。通过与Lock配合使用，可以实现更灵活、更细粒度的线程控制。掌握Condition的基础概念、使用方法、常见实践以及最佳实践，能够帮助开发人员编写高效、可靠的多线程应用程序。

参考资料

• Java官方文档 - java.util.concurrent.locks.Condition
• 《Effective Java》 - Joshua Bloch
• 《Java并发编程实战》 - Brian Goetz