基于 BlockQueue 实现的生产者-消费者

package com.ggg.coroutinedemo.blockqueue;

import java.util.concurrent.*;

/**
 * @author ggg
 * @version 1.0
 * @date 2019/2/14 15:19
 * @description
 */
public class BlockQueueMain {
    public static void main(String[] args) throws InterruptedException {

        BlockingQueue<String> queue = new LinkedBlockingDeque<>(10);
        Producter producter1 = new Producter(queue);
        Producter producter2 = new Producter(queue);
        Producter producter3 = new Producter(queue);
        Producter producter4 = new Producter(queue);
        Producter producter5 = new Producter(queue);


        Consumer consumer1 = new Consumer(queue);
        Consumer consumer2 = new Consumer(queue);
        Consumer consumer3 = new Consumer(queue);
        Consumer consumer4 = new Consumer(queue);
        Consumer consumer5 = new Consumer(queue);
        Consumer consumer6 = new Consumer(queue);
        Consumer consumer7 = new Consumer(queue);
        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.execute(producter1);
        executorService.execute(producter2);
        executorService.execute(producter3);
        executorService.execute(producter4);
        executorService.execute(producter5);

        executorService.execute(consumer1);
        executorService.execute(consumer2);
        executorService.execute(consumer3);
        executorService.execute(consumer4);
        executorService.execute(consumer5);
        executorService.execute(consumer6);
        executorService.execute(consumer7);

        Thread.sleep(10 * 1000);
        producter1.stop();
        producter2.stop();
        producter3.stop();
        producter4.stop();
        producter5.stop();

        Thread.sleep(10 * 1000);
        executorService.shutdown();
    }
}

package com.ggg.coroutinedemo.blockqueue;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author ggg
 * @version 1.0
 * @date 2019/2/14 15:20
 * @description
 */
public class Consumer implements Runnable {
    private BlockingQueue<String> queue;
    private boolean isRunning = true;

    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {
        try {
            while (isRunning) {

                String data = queue.poll(5000, TimeUnit.MILLISECONDS);//超时5s则判断为生产者退出
                if (data == null) {
                    isRunning = false;
                } else {
                    System.out.println("读取:" + data);
                    Thread.sleep(3000);
                }

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            isRunning = false;
            Thread.currentThread().interrupt();

        } finally {
            System.out.println("consumer end");

        }
    }
}

package com.ggg.coroutinedemo.blockqueue;

import java.util.Random;
import java.util.concurrent.BlockingQueue;

/**
 * @author ggg
 * @version 1.0
 * @date 2019/2/14 15:19
 * @description
 */
public class Producter implements Runnable {
    private BlockingQueue<String> queue;//存储数据的队列
    private boolean isRunning = true;

    public Producter(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void stop() {
        isRunning = false;
    }

    @Override
    public void run() {
        try {
            isRunning = true;
            while (isRunning) {

                Random random = new Random();
                System.out.println("放入的数据：producer-" + random.nextInt());
                queue.offer("producer-" + random.nextInt());//将数据放到队列中
                Thread.sleep(1000);

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            isRunning = false;
            Thread.currentThread().interrupt();

        } finally {
            System.out.println("producter end");

        }
    }
}

参考的资料-jack.yujun关于blockqueque的文章