002 AQS核心-Condition条件判断的使用

        我们在使用synchronized的时候，如果需要多线程间进行协作工作则需要Object的wait()和notify()、notifyAll()方法进行配合工作。

        那么同样，我们在使用Lock的时候，可以使用一个新的等待/通知的类，它就是Condition。这个Condition一定是针对具体某一把锁的。也就是在只有锁的基础之上才会产生Condition。

        我们可以通过一个Lock对象产生多个Condition进行多线程间的交互，非常的灵活。可以使得部分需要唤醒的线程唤醒，其他线程则继续等待通知。

/* 单个Condition的应用
 * 核心在于condition.await()阻塞等待释放锁和condition.signal()发信号唤醒的应用
 */

public class UseCondition {
    //创建一个ReentrantLock锁对象(Condition需要配合着ReentrantLock锁使用)
    private Lock lock = new ReentrantLock();
    
    //synchronized   wait   notify
    //基于这把锁产生一个condition：作用是对应这把锁的唤醒和阻塞等待操作
    private Condition condition = lock.newCondition();
    
    public void method1() {
        lock.lock();
        try {
            System.out.println("当前线程："+Thread.currentThread().getName()+"进入等待状态...");
            Thread.sleep(3000);
            System.out.println("当前线程："+Thread.currentThread().getName()+"释放锁...");
            condition.await();//释放锁，并进入阻塞状态，等待另外一个线程唤醒自己
            System.out.println("当前线程："+Thread.currentThread().getName()+"继续执行...");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread().getName()+"...unlock");
            lock.unlock();
        }
    }
    
    public void method2() {
        lock.lock();
        try {
            System.out.println("当前线程："+Thread.currentThread().getName()+"进入...");
            Thread.sleep(3000);
            System.out.println("当前线程："+Thread.currentThread().getName()+"唤醒...t1");
            condition.signal();//唤醒method1
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        final UseCondition uc = new UseCondition();
        
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                uc.method1();
            }
        },"t1");
        
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                uc.method2();
            }
        },"t2");
        t1.start();
        Thread.sleep(1);
        t2.start();
        
    }

}

输出结果：

当前线程：t1进入等待状态...
当前线程：t1释放锁...
当前线程：t2进入...
当前线程：t2唤醒...t1
t2...unlock
当前线程：t1继续执行...
t1...unlock
 

/* 前三个方法都是拿到锁后进入阻塞等待状态，释放锁，等待唤醒；
 * method4拿到锁之后执行并且唤醒了condition1.signalAll()条件下所有阻塞的线程
 * method5拿到锁之后执行并且唤醒了condition2.signalAll()条件下所有阻塞的线程
 * 实际工作中使用ReentrantLock配合Condition更加灵活
 */
public class UseManyCondition {
    
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();

    
    public void method1() {
        lock.lock();
        try {
            System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法method1等待...");
            condition1.await();//释放锁，并进入阻塞状态，等待另外一个线程唤醒自己
            System.out.println("当前线程："+Thread.currentThread().getName()+"方法method1继续执行...");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread().getName()+"...unlock");
            lock.unlock();
        }
    }
    
    public void method2() {
        lock.lock();
        try {
            System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法method2等待...");
            condition1.await();
            System.out.println("当前线程："+Thread.currentThread().getName()+"方法method2继续...");
            
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread().getName()+"...unlock");
            lock.unlock();
        }
    }
        
        public void method3() {
            lock.lock();
            try {
                System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法method3等待...");
                condition2.await();
                System.out.println("当前线程："+Thread.currentThread().getName()+"方法method3继续...");
                
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                System.out.println(Thread.currentThread().getName()+"...unlock");
                lock.unlock();
            }
        }
            
            public void method4() {
                lock.lock();
                try {
                    System.out.println("当前线程："+Thread.currentThread().getName()+"唤醒...");
                    condition1.signalAll();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"...unlock");
                    lock.unlock();
                }
            }
            public void method5() {
                lock.lock();
                try {
                    System.out.println("当前线程："+Thread.currentThread().getName()+"唤醒...");
                    condition2.signalAll();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"...unlock");
                    lock.unlock();
                }
            }
    
    public static void main(String[] args){
        final UseManyCondition ucm = new UseManyCondition();
        
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                ucm.method1();
            }
        },"t1");
        
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                ucm.method2();
            }
        },"t2");
        
        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                ucm.method3();
            }
        },"t3");
        
        Thread t4 = new Thread(new Runnable() {

            @Override
            public void run() {
                ucm.method4();
            }
        },"t4");
        
        Thread t5 = new Thread(new Runnable() {

            @Override
            public void run() {
                ucm.method5();
            }
        },"t5");
        
        
        t1.start();
        t2.start();
        t3.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t4.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t5.start();
    }
}

输出结果：

当前线程：t3进入方法method3等待...
当前线程：t1进入method1等待...
当前线程：t2进入方法method2等待...
当前线程：t4唤醒...
t4...unlock
当前线程：t1方法method1继续执行...
t1...unlock
当前线程：t2方法method2继续...
t2...unlock
当前线程：t5唤醒...
t5...unlock