使用BlockingQueue实现WaxOnWaxOff程序

最新推荐文章于 2022-03-30 10:44:15 发布

原创最新推荐文章于 2022-03-30 10:44:15 发布 · 373 阅读

0 ·

CC 4.0 BY-SA版权

java_concurrency 专栏收录该内容

28 篇文章

订阅专栏

本文介绍了一种使用同步队列（BlockingQueue）和线程池（ExecutorService）实现任务调度的方法，通过实例演示了如何让两个任务（WaxOn 和 WaxOff）交替执行，避免了使用 wait 和 notifyAll 的复杂性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. Car程序

class Car{

    Logger logger = LoggerFactory.getLogger(Car.class);

    public void waxOn(){
        logger.info("wax On");
    }

    public void waxOff(){
        logger.info("wax Off");
    }
}

2. WaxOn任务

class WaxOn implements Runnable{

    private Car car;

    public WaxOn() {

    }

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

    @Override
    public void run() {
        car.waxOn();
    }
}

3. WaxOff任务

class WaxOff implements Runnable {

    private Car car;

    public WaxOff(){

    }

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

    @Override
    public void run() {
        car.waxOff();
    }
}

4. WaxRunner消费者任务

class WaxRunner implements Runnable {

    private BlockingQueue queue;

    public WaxRunner(BlockingQueue queue){
        this.queue = queue;
    }

    @Override
    public void run() {
        while (!queue.isEmpty()) {
            Object remove = queue.remove();
            if(remove.getClass().isInstance(new WaxOn())){
                ((WaxOn)remove).run();
            }else{
                ((WaxOff)remove).run();
            }
        }
    }
}

5. 测试类

public class TestWaxBlockingQueue {

    public static void main(String[] args){
        Car car = new Car();
        //执行三次waxOn waxOff
        BlockingQueue queue = new LinkedBlockingDeque();
        for (int i = 1; i <= 3; i++) {
            WaxOn waxOnTask = new WaxOn(car);
            queue.add(waxOnTask);
            WaxOff waxOffTask = new WaxOff(car);
            queue.add(waxOffTask);
        }
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new WaxRunner(queue));
        try {
            TimeUnit.MILLISECONDS.sleep(3000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }
}

运行结果：

类图：

对于WaxOnWaxOff程序的实现，一种是使用wait和notifyAll来实现，另一种是使用同步队列来实现。

总结来说：

1. wait()和notifyAll()方法以一种非常低级的方式解决了任务互操作问题，即每次交互时都握手。而同步队列是更高的抽象级别。

2. BlockingQueue将多个任务的执行串行化，而且均在消费者线程上执行多个任务

3. 在使用BlockingQueue时没有使用任何显示的同步（如Lock对象或Synchronized关键字），因为同步由队列（其内部是同步的）和系统的设计隐式地管理了。因为队列的阻塞，使得处理过程将被自动地挂起和恢复。你可以看到由BlockingQueue产生的简化十分明显。在使用显式的wait()和notify()时存在的类和类之间的耦合被消除了，因为每个任务类都只和它的BlockingQueue通信。

4. 如何像消费者线程中传递信息呢？在这里是将装载任务的BlockingQueue通过构造函数，设置任务类的字段实现的