Condition实现线程的通信

一、Condition是接口

1.创建ReentrantLock
2.调用它的newCondition方法获取Condition

Condition实现线程的通信

使用Condition实现一个有界的队列

ConditionObject是Condition的唯一一个实现

1.线程没获取到锁就会被放到同步队列中 （双向链表） 线程在竞争cpu时间片，执行

2.调用awatiy()方法就会把线程放到等待队列中（单向链表）
2.1把线程放到等待队列
2.2释放锁
2.3signal()方法把线程从等待队列移到同步队列中

每newCondition都会创建一个新的等待队列

package com.roy.condition;

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

/**
 * @Authror royLuo
 * @Date 2020/2/20 15:24
 **/
public class ConditionDemo {

    //定义信号量
    private int signal;

   private Lock lock = new ReentrantLock();
   private Condition a = lock.newCondition();
   private Condition b = lock.newCondition();
   private Condition c = lock.newCondition();

    public void a(){
        lock.lock();
        while (signal!=0){
             try {
                 a.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         signal++;
        System.out.println("a");
        b.signal();
        lock.unlock();
    }
    public void b(){
        lock.lock();
        while (signal!=1){
            try {
                b.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        signal++;
        System.out.println("b");
        c.signal();
        lock.unlock();
    }
    public void c(){
         lock.lock();
         while (signal!=2){
             try {
                 c.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         signal = 0;
         a.signal();
        System.out.println("c");
         lock.unlock();
    }



    public static void main(String[] args) {
        ConditionDemo demo = new ConditionDemo();
        A a = new A(demo);
        B b = new B(demo);
        C c = new C(demo);
        new Thread(a).start();
        new Thread(b).start();
        new Thread(c).start();
    }

}
class A  implements Runnable{

    private  ConditionDemo demo;


    public A(ConditionDemo demo){
        this.demo =demo;
    }

    @Override
    public void run() {
        while (true)
        demo.a();
    }
}
class B  implements Runnable{

    private  ConditionDemo demo;


    public B(ConditionDemo demo){
        this.demo =demo;
    }

    @Override
    public void run() {
        while (true)
        demo.b();
    }
}
class C  implements Runnable{

    private  ConditionDemo demo;


    public C(ConditionDemo demo){
        this.demo =demo;
    }

    @Override
    public void run() {
        while (true)
        demo.c();
    }
}