多线程——Condition的使用

多线程——Condition的使用

Condition是在java 1.5中才出现的，用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来模拟线程间协作。

1. Condition是个接口，基本的方法就是await()和signal()方法；
   Condition依赖于Lock接口，生成一个Condition的基本代码是

Condition condition = lock.newCondition();

2. 调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()；

lock.lock();
try{
    // 判断,注意不能用if（只判断一次），
    //需要用while，被唤醒后需要在判断一次
    while (number!=0){
        condition.await();
    }
    number++;
    condition.signalAll();
}catch(Exception e){
    e.printStackTrace();
}finally{
    lock.unlock();
}

• Condition的执行方式，是当在线程Consumer中调用await方法后，线程Consumer将释放锁，并且将自己沉睡，等待唤醒，线程获取到锁后，开始做事，完毕后，调用Condition的signalAll方法，唤醒线程，线程恢复执行。

• Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。

多线程之间按顺序调用，实现A-B-C

A打印5次，B打印10次，C打印15次，来5轮

Condition实现精准调用

Lock lock = new ReentrantLock();
ReentrantLock:可重入递归非公平锁

class ShareData{
    private int number = 1; //A:1;B:2;C:3;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print(){
        lock.lock();
        try{//线程操作资源类，
            if ("A".equals(Thread.currentThread().getName())){
                while (number!=1){
                    c1.await();
                }
                for (int i = 1; i <= 2; i++) {
                    System.out.println(Thread.currentThread().getName()+"\t"+i);
                }
                number = 2;
                c2.signal();
            }else if ("B".equals(Thread.currentThread().getName())){
                while (number!=2){
                    c2.await();
                }
                for (int i = 1; i <= 4; i++) {
                    System.out.println(Thread.currentThread().getName()+"\t"+i);
                }
                number = 3;
                c3.signal();
            }else{
                while (number!=3) {
                    c3.await();
                }
                for (int i = 1; i <= 6; i++) {
                    System.out.println(Thread.currentThread().getName()+"\t"+i);
                }
                number = 1;
                c1.signal();
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

}

/**
 * 多线程之间按顺序调用，实现A-B-C
 * A打印5次，B打印10次，C打印15次，来5轮
 * Condition实现精准调用
 */
public class ConditionDemo {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareData.print();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareData.print();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareData.print();
            }
        }, "C").start();
    }
}

运行结果如下

A	1
A	2
B	1
B	2
B	3
B	4
C	1
C	2
C	3
C	4
C	5
C	6
A	1
A	2
B	1
B	2
B	3
B	4
C	1
C	2
C	3
C	4
C	5
C	6
A	1
A	2
B	1
B	2
B	3
B	4
C	1
C	2
C	3
C	4
C	5
C	6

进程已结束,退出代码0