采用ConcurrentLinkedQueue实现生产者，消费者模型

生产者，消费者模型在我们实际开发过程中经常用到。就用ConcurrentLinkedQueue来实现个简单的Demo。

---

一、介绍

ConcurrentLinkedQueue
是单向链表结构的无界并发队列。从JDK1.7开始加入到J.U.C的行列中。使用CAS实现并发安全，元素操作按照 FIFO(first-in-first-out 先入先出) 的顺序。适合“单生产，多消费”的场景。内存一致性遵循对ConcurrentLinkedQueue的插入操作先行发生于(happen-before)访问或移除操作。
拓展下另一个相关的并发队列:
ConcurrentLinkedDeque
是双向链表结构的无界并发队列。与 ConcurrentLinkedQueue 的区别是该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)。适合“多生产，多消费”的场景。内存一致性遵循对 ConcurrentLinkedDeque 的插入操作先行发生于(happen-before)访问或移除操作。

---

二、代码实现

package com.advance.mistra.solution.producerconsumer;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author: Mistra
 * @Version: 1.0
 * @Time: 2020/2/2 16:54
 * @Description: 生产者消费者模型，采用1个生产者，多个消费者的形式
 * @Copyright (c) Mistra,All Rights Reserved.
 * @Github: https://github.com/MistraR
 * @CSDN: https://blog.csdn.net/axela30w
 */
@Slf4j
@Component
public class ProducerConsumerTest {

    /**
     * 待处理任务队列
     */
    public static ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
    /**
     * 消费者线程个数
     */
    private static int threadCount = 5;
    /**
     * 线程池
     * LinkedBlockingQueue阻塞队列，默认为Integer.MAX_VALUE  -  无界队列
     */
    private static ExecutorService executorService = new ThreadPoolExecutor(threadCount + 1, threadCount + 1,
            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1000), new NameTreadFactory());

    private static volatile AtomicInteger stopProduce = new AtomicInteger(0);

    @PostConstruct
    private void init() {
        executorService.submit(new Producer());
        for (int i = 1; i <= threadCount; i++) {
            executorService.submit(new Consumer());
        }
    }

    /**
     * 生产者
     */
    static class Producer implements Runnable {

        @SneakyThrows
        @Override
        public void run() {
            while (true) {
                try {
                    // 只生产15个
                    if (stopProduce.intValue() < 15) {
                        queue.add("队列元素" + System.currentTimeMillis());
                        Thread.sleep(1000);
                        stopProduce.incrementAndGet();
                    }
                } catch (Exception e) {
                    log.info("线程发生异常！---------------------------------------------------------------------");
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 消费者
     */
    static class Consumer implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    if (!queue.isEmpty()) {
                        String str = queue.poll();
                        if (str != null && !str.isEmpty()) {
                            log.info("线程:{},消费:{}", Thread.currentThread().getName(), str);
                        }
                    } else {
                        Thread.sleep(100);
                    }
                } catch (Exception e) {
                    log.info("线程发生异常！---------------------------------------------------------------------");
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 自定义的线程名称类
     * 定义线程池时使用
     */
    static class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger threadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r, "my-thread-" + threadNum.getAndIncrement());
            log.info("{} has been created", thread.getName());
            return thread;
        }
    }

}

生产者生产15个消息放入队列，就停止了。启动多个线程来从队列中消费消息。