Lock中使用Condition实现等待通知

• Condition类有很好的灵活性，可以实现多路通知功能，一个Lock对象中可以创建多个Condition对象实例，线程对象可以注册在指定的Condition中，进而有选择的进行线程通知，在调度线程上更加灵活
• wait与notify/notifyAll进行等待通知时，被通知的线程是随机的，但是Condition与Lock结合的通知是有选择性的通知
• synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有线程对象都注册在一个Condition对象身上，线程开始notifyAll时，需要通知所有的WAITING线程，没有选择性，会出现很大的效率问题

 public class MyService {
     private Lock lock = new ReentrantLock();
     public Condition condition = lock.newCondition();
     public void await(){
         try {
             lock.lock();
             System.out.println("await时间为"+System.currentTimeMillis());
             condition.await();
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 
     public void signal(){
         try {
             lock.lock();
             System.out.println("signal时间为"+System.currentTimeMillis());
             condition.signal();
         } finally {
             lock.unlock();
         }
     }
 }

 public class MyThread extends Thread {
     private MyService service;
 
     public MyThread(MyService service) {
         this.service = service;
     }
 
     @Override
     public void run() {
         service.await();
     }
 }

 public class Run {
     public static void main(String[] args) {
         try {
             MyService service = new MyService();
             MyThread mt = new MyThread(service);
             mt.start();
             Thread.sleep(3000);
             service.signal();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

-------------------------------------------------------打印输出-------------------------------------------------------

await时间为1537949157830
signal时间为1537949160830

Condition类中的await方法相当于Object类中的wait方法

Condition类中的signal/signalAll方法相当于Object类中的notify/notifyAll方法

案例2

 public class MyService {
     private Lock lock = new ReentrantLock();
     public Condition condition = lock.newCondition();
 
     public void awaitA(){
         try {
             lock.lock();
             System.out.println("begin awaitA时间为"+System.currentTimeMillis()+ " ThreadName="+Thread.currentThread().getName());
             condition.await();
             System.out.println("end awaitA时间为"+System.currentTimeMillis()+ " ThreadName="+Thread.currentThread().getName());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
 
         }
     }
 
     public void awaitB(){
         try {
             lock.lock();
             System.out.println("begin awaitB时间为"+System.currentTimeMillis()+ " ThreadName="+Thread.currentThread().getName());
             condition.await();
             System.out.println("end awaitB时间为"+System.currentTimeMillis()+ " ThreadName="+Thread.currentThread().getName());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 
     public void signalAll(){
         try {
             lock.lock();
             System.out.println("signalAll时间为"+System.currentTimeMillis()+ " ThreadName="+Thread.currentThread().getName());
             condition.signalAll();
         } finally {
             lock.unlock();
         }
     }
 }

线程

 public class ThreadA extends Thread {
     private MyService service;
 
     public ThreadA(MyService service) {
         this.service = service;
     }
 
     @Override
     public void run() {
         service.awaitA();
     }
 }
 -------------------------------------------------
 public class ThreadB extends Thread {
     private MyService service;
 
     public ThreadB(MyService service) {
         this.service = service;
     }
 
     @Override
     public void run() {
         service.awaitB();
     }
 }

 public class Run {
     public static void main(String[] args) throws InterruptedException {
         MyService service = new MyService();
         ThreadA a = new ThreadA(service);
         a.setName("A");
         ThreadB b = new ThreadB(service);
         b.setName("B");
         a.start();
         b.start();
         Thread.sleep(3000);
         service.signalAll();
     }
 }

-------------------------------------------------------打印输出-------------------------------------------------------

begin awaitA时间为1537951494924 ThreadName=A
begin awaitB时间为1537951494925 ThreadName=B
signalAll时间为1537951497924 ThreadName=main
end awaitA时间为1537951497924 ThreadName=A
end awaitB时间为1537951497925 ThreadName=B

线程A和B都被唤醒了

---

使用多个Condition实现通知部分线程

想要单独唤醒部分线程，就需要使用多个Condition对象，先对线程进行分组，Condition对象可以唤醒部分指定线程，有助于提高程序运行效率

 public class MyService {
     private Lock lock = new ReentrantLock();
     public Condition conditionA = lock.newCondition();
     public Condition conditionB = lock.newCondition();
 
     public void awaitA(){
         try {
             lock.lock();
             System.out.println("begin awaitA时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
             conditionA.await();
             System.out.println("--end awaitA时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 
     public void awaitB(){
         try {
             lock.lock();
             System.out.println("begin awaitB时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
             conditionB.await();
             System.out.println("--end awaitB时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 
     public void signAll_A(){
         try {
             lock.lock();
             System.out.println("signAll_A时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
             conditionA.signalAll();
         } finally {
             lock.unlock();
         }
     }
 
     public void signAll_B(){
         try {
             lock.lock();
             System.out.println("signAll_B时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
             conditionB.signalAll();
         } finally {
             lock.unlock();
         }
     }
 }

线程

 public class ThreadA extends Thread {
     private MyService service;
 
     public ThreadA(MyService service) {
         this.service = service;
     }
 
     @Override
     public void run() {
         service.awaitA();
     }
 }
 -----------------------------------------------
 public class ThreadB extends Thread {
     private MyService service;
 
     public ThreadB(MyService service) {
         this.service = service;
     }
 
     @Override
     public void run() {
         service.awaitB();
     }
 }

 public class Run {
     public static void main(String[] args) throws InterruptedException {
         MyService service = new MyService();
         ThreadA a = new ThreadA(service);
         a.setName("A");
         ThreadB b = new ThreadB(service);
         b.setName("B");
         a.start();
         b.start();
         Thread.sleep(3000);
         service.signAll_A();
     }
 }

-------------------------------------------------------打印输出-------------------------------------------------------

begin awaitA时间为1537952328573 ThreadName=A
begin awaitB时间为1537952328573 ThreadName=B
signAll_A时间为1537952331572 ThreadName=main
--end awaitA时间为1537952331572 ThreadName=A

线程A被唤醒了，但是线程B仍然在等待