Lock和Condition对象的使用

Love The Way You Lie 2022-06-15 08:11 190阅读 0赞

Condition的await()方法

void await()
        throws InterruptedException

导致当前线程等到发信号或 interrupted 。

与此相关的锁`Condition`以原子方式释放，并且当前线程的线程调度目的就退出，一直处于休眠状态的四两件事*发生对象* ：

*  一些其它线程调用`signal()`方法本`Condition`和当前线程碰巧被选择作为被唤醒线程; 要么
 *  一些其他的线程调用88452369060832方法`Condition` ; 要么
 *  一些其他线程interrupts当前线程，并中断线程挂起; 要么
 *  发生“ *虚假唤醒* ”。

在所有情况下，在此方法返回之前，当前线程必须重新获取与此条件相关的锁。 当线程返回时，它*保证*保持此锁。

实现两个线程交替执行的案例：

class Car{
        private Lock lock=new ReentrantLock();
        private Condition condition=lock.newCondition();
        private boolean waxOn=false;
        public void waxed(){
            lock.lock();
            try {
                waxOn=true;
                condition.signalAll();//唤醒所有等待线程
            } finally {
                lock.unlock();
            }
        }
        public void buffed(){
            lock.lock();
            try {
                waxOn=false;
                condition.signalAll();
            } finally {
                lock.unlock();
            }
        }
        public void waitForWaxing() throws InterruptedException{
            lock.lock();
            try {
                while(waxOn==false)
                    condition.await();//挂起当前线程，释放锁
            } finally {
                lock.unlock();
            }
        }
        public void waitForBuffing() throws InterruptedException{
            lock.lock();
            try {
                while(waxOn==true)
                    condition.await();
            } finally {
                lock.unlock();
            }
        }
    }
    class WaxOn implements Runnable{
        private Car car;
        public WaxOn(Car c){
            car=c;
        }
    
        @Override
        public void run() {
            try {
                while(!Thread.interrupted()){
                    System.out.println("Wax on!");
                    TimeUnit.MILLISECONDS.sleep(200);
                    car.waxed();
                    car.waitForBuffing();
                }
            } catch (InterruptedException e) {
                System.out.println("Exiting via interrupt");
            }
            System.out.println("Ending Wax On task");
        }
    }
    class WaxOff implements Runnable{
        private Car car;
        public WaxOff(Car c){
            car=c;
        }
    
        @Override
        public void run() {
            try {
                while (!Thread.interrupted()){
                    car.waitForWaxing();
                    System.out.println("Wax Off!");
                    TimeUnit.MILLISECONDS.sleep(200);
                    car.buffed();
                }
            } catch (InterruptedException e) {
                System.out.println("Exiting via interrupt");
            }
            System.out.println("Ending Wax Off task");
        }
    }
    public class WaxOMatic2 {
        public static void main(String[] args) throws Exception{
            Car car=new Car();
            ExecutorService exec= Executors.newCachedThreadPool();
            exec.execute(new WaxOff(car));
            exec.execute(new WaxOn(car));
            TimeUnit.SECONDS.sleep(5);
            exec.shutdownNow();
        }
    }

Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Wax Off!  
Wax on!  
Exiting via interrupt  
Ending Wax On task  
Exiting via interrupt  
Ending Wax Off task