java编程思想笔记-并发之线程协作(三)

Condition类简介
使用互斥并允许任务挂起的基本类是Condition，可以使用Condition上的await()来挂起一个任务，可以使用signal()通知一个任务，signalAll()唤醒所有在这个Condition上挂起的任务，与notifyAll()相比，signalAll()是更安全的方式，同时任务在调用await(),signal()或者signalAll()必须拥有这个锁

使用concurrent类库的Condition重写汽车打蜡抛光的例子

package com.tij.thread.cooperate;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Car2 {
    private Lock lock = new ReentrantLock();
    //使用lock创建一个condition对象，管理任务通信
    private Condition condition = lock.newCondition();
    private boolean waxOn = false;

    public void waxed() {
        lock.lock();
        //使用try-finally保证在所有情况下释放锁
        try {
            waxOn = true;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void buffed() {
        lock.lock();
        try {
            waxOn = false;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    // 必须让线程获取锁线程才能wait
    public void waitForWaxing() throws InterruptedException {
        lock.lock();
        try {
            while (!waxOn) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }

    // 必须让线程获取锁线程才能wait
    public void waitForBuffing() throws InterruptedException {
        lock.lock();
        try {
            while (waxOn) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }
}

class WaxOn2 implements Runnable {
    private Car car;

    public WaxOn2(Car car) {
        this.car = car;
    }

    @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("WaxOn Exiting via interrupt ");
        }
        System.out.println(" Ending Wax On task ");
    }
}

class WaxOff2 implements Runnable {
    private Car car;

    public WaxOff2(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                car.waitForWaxing();
                System.out.println(" Wax Off ! ");
                TimeUnit.MILLISECONDS.sleep(200);
                car.buffed();
            }
        } catch (Exception e) {
            System.out.println("WaxOff Exiting via interrupt ");
        }
        System.out.println(" Ending Wax Off task ");
    }
}

public class WaxOMatic2 {
    public static void main(String[] args) throws InterruptedException {
        Car car = new Car();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new WaxOff(car));
        exec.execute(new WaxOn(car));
        TimeUnit.SECONDS.sleep(5);
        exec.shutdownNow();
    }
}