Java多线程六脉神剑-关冲剑(Condition)、中冲剑(BlockingQueue)

1ms【毫秒】 = 1000μs【微秒】    1μs【微秒】 = 1000ns【纳秒】

public class ConditionCase {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Object object = null;
    private boolean produced = false; //是否已经生产
    private boolean consumed = false; //是否已经消费

    public void producer() {
        lock.lock();
        try {
            // 假设生产条件未满足 或 还未进行消费，等待
            while (!isProductionReady() || consumed) {
                condition.await();
            }
            // 进行生产操作
            object = new Object();
            produced = true;
            System.out.println("生产完成,可以消费");
            // 通知消费者可以消费
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consumer() {
        lock.lock();
        try {
            // 假设消费条件未满足，等待
            while (!isConsumptionReady() ||!produced) {
                condition.await();
            }
            // 进行消费操作
            object = null;
            consumed = true;
            System.out.println("消费完成");
            // 通知生产者可以生产
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    private boolean isProductionReady() {
        // 这里可以根据实际情况判断生产条件是否满足
        return true;
    }

    private boolean isConsumptionReady() {
        // 这里可以根据实际情况判断消费条件是否满足
        return true;
    }

    public static void main(String[] args) {
        ConditionCase conditionCase = new ConditionCase();

        new Thread(() -> conditionCase.consumer()).start();
        new Thread(() -> conditionCase.producer()).start();
    }
}

生产完成,可以消费
消费完成

public class BlockingQueueCase {
    //初始任务队列
    static BlockingQueue<Task> blockingQueue;
    public static void produce(List<Task> taskList) throws InterruptedException {
        blockingQueue = new ArrayBlockingQueue<>(taskList.size());
        //将任务放到任务队列中
        for (Task task : taskList) {
            blockingQueue.put(task);
        }
    }

    /**
     * 消费任务
     * @param consumerNum 消费者数量
     */
    public static void consume(int consumerNum, CountDownLatch latch){
        for(int i = 1; i <= consumerNum; i++){
            //消费者消费任务
            Thread thread = new Thread(() -> {
                Task task;
                //当任务队列中还有需要执行的任务
                while((task = blockingQueue.poll()) != null){
                    //业务执行
                    try {
                        Thread.sleep(task.getTime());
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "完成任务:"+task.getName()+",耗时:"+task.getTime()+"毫秒");
                    latch.countDown();
                }
            },"线程"+i);
            thread.start();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //模拟5个待执行任务
        List<Task> taskList = new ArrayList<>();
        taskList.add(new Task("CPU",2000L));
        taskList.add(new Task("主板",800L));
        taskList.add(new Task("内存",500L));
        taskList.add(new Task("显卡",1000L));
        taskList.add(new Task("电源",200L));
        //5个任务放到队列中
        produce(taskList);
        //latch用于主线程等待线程把任务都执行完毕
        CountDownLatch latch = new CountDownLatch(taskList.size());
        //2个消费者消费任务
        consume(2,latch);
        latch.await();
        System.out.println("任务都执行完毕");
    }
}