Java Lock锁Condition接口和newCondition()方法

文
章
目
录

• Condition接口
• Condition实现等待/通知机制
• 多个Condition实例实现等待/通知机制
•  总结

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，之前我们讲过《Java多线程：线程间通信（等待/通知机制）》，ReentrantLock类也可以借助于Condition接口与newCondition()方法。

synchronized关键字在使用notify/notifyAll()方法进行通知时，被通知的线程是由JVM选择的，使用ReentrantLock类结合Condition实例可以实现“选择性通知”。

synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在该一个实例上。

如果执行notifyAll()方法的话就会通知所有处于等待状态的线程，这样会造成很大的效率问题，而Condition可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。从而可以有选择性的进行线程通知，在调度线程上更加灵活。

Condition接口

    //使当前线程在接到信号或被中断之前一直处于等待状态。
    void await();
 
    //使当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
    boolean await(long time, TimeUnit unit);
 
    //使当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
    long awaitNanos(long nanosTimeout);
 
    //使当前线程在接到信号之前一直处于等待状态。
    void awaitUninterruptibly();
 
    //使当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。
    boolean awaitUntil(Date deadline);
 
    //唤醒一个等待线程。
    void signal();
 
    //唤醒所有等待线程。
    void signalAll();

Condition实现等待/通知机制

当调用 await() 语句后，线程将被阻塞，必须执行完signal()所在的try语句块之后才释放锁，condition.await()后的语句才能被执行。

package ReentrantLockTest;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Test {
 
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
 
        MyThread a = new MyThread(service);
        a.start();
 
        Thread.sleep(3000);
 
        service.signal();
    }
 
    static public class MyService {
 
        private Lock lock = new ReentrantLock();
 
        public Condition condition = lock.newCondition();
 
        public void await() {
            lock.lock();
            try {
                System.out.println(\"准备调用condition.await()方法，将该线程阻塞\");
                condition.await();
                System.out.println(\"已调用condition.await()方法，此时已被 signal() 方法唤醒\");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
 
        public void signal() {
            lock.lock();
            try {
                System.out.println(\"准备调用condition.signal()方法\");
                condition.signal();
                Thread.sleep(3000);
                System.out.println(\"已调用condition.signal()方法，去唤醒 await() 方法\");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
 
 
    static public class MyThread extends Thread {
        private MyService service;
 
        public MyThread(MyService service) {
            this.service = service;
        }
 
        @Override
        public void run() {
            service.await();
        }
    }
 
}

输出如下：

准备调用condition.await()方法，将该程序阻塞
准备调用condition.signal()方法
已调用condition.signal()方法，去唤醒 await() 方法
已调用condition.await()方法，此时已被 signal() 方法唤醒

多个Condition实例实现等待/通知机制

一个Lock对象中可以创建多个Condition实例，调用某个实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。

package ReentrantLockTest;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class LockTest {
 
    private Lock lock = new ReentrantLock();
 
    private Condition conditionA = lock.newCondition();
 
    private Condition conditionB = lock.newCondition();
 
    public void awaitA() {
        lock.lock();
        try {
            System.out.println(\"准备调用conditionA.await()方法，将该线程阻塞\");
            conditionA.await();
            System.out.println(\" awaitA 已被唤醒\");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void awaitB() {
        lock.lock();
        try {
            System.out.println(\"准备调用conditionB.await()方法，将该线程阻塞\");
            conditionB.await();
            System.out.println(\" awaitB 已被唤醒\");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void signalA() {
        lock.lock();
        try {
            System.out.println(\"准备唤醒 conditionA 下的所有线程\");
            conditionA.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void signalB() {
        lock.lock();
        try {
            System.out.println(\"准备唤醒 conditionB 下的所有线程\");
            conditionB.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
}

package ReentrantLockTest;
 
public class Test {
 
    public static void main(String[] args) throws InterruptedException {
 
        LockTest lockTest = new LockTest();
 
        ThreadA a = new ThreadA(lockTest);
        a.setName(\"A\");
        a.start();
 
        ThreadB b = new ThreadB(lockTest);
        b.setName(\"B\");
        b.start();
 
        Thread.sleep(3000);
 
        lockTest.signalA();
 
    }
 
    static public class ThreadA extends Thread {
 
        private LockTest lockTest;
 
        public ThreadA(LockTest lockTest) {
            this.lockTest = lockTest;
        }
 
        @Override
        public void run() {
            lockTest.awaitA();
        }
    }
 
    static public class ThreadB extends Thread {
 
        private LockTest lockTest;
 
        public ThreadB(LockTest lockTest) {
            this.lockTest = lockTest;
        }
 
        @Override
        public void run() {
            lockTest.awaitB();
        }
    }
}

程序输出：

准备调用conditionA.await()方法，将该线程阻塞
准备调用conditionB.await()方法，将该线程阻塞
准备唤醒 conditionA 下的所有线程
 awaitA 已被唤醒

 总结

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。Condition的强大之处在于，对于一个锁，我们可以为多个线程间建立不同的Condition。

如果采用Object类中的wait(), notify(), notifyAll()实现的话，当写入数据之后需要唤醒读线程时，不可能通过notify()或notifyAll()明确的指定唤醒读线程，而只能通过notifyAll唤醒所有线程，但是notifyAll无法区分唤醒的线程是读线程，还是写线程。所以，通过Condition能够更加精细的控制多线程的休眠与唤醒。

以上就是Java Lock锁Condition接口和newCondition()方法的详解。