java实现一个阻塞队列（生产者消费者模式）

首先实现一个简单的链表队列，头插元素，尾删元素。

package com.zwj;


import java.util.concurrent.atomic.AtomicInteger;

public class MyQueue<T> {
    private volatile node head;
    private volatile node tail;
    private volatile AtomicInteger size = new AtomicInteger(0);
    private int length;


    public MyQueue(T t) {
        head = create(t);
        tail = head;
        size.incrementAndGet();
    }

    class node<T> {
        public T value;
        public node nex;

        public node(T t) {
            this.value = t;
            this.nex = null;
        }
    }


    private node create(T t) {
        node root = new node(t);
        root.nex = null;
        return root;
    }

    public Boolean put(T t, int capality) {
        if (tail != null && size.get() < capality) {
            node newNode = new node(t);
            tail.nex = newNode;
            tail = tail.nex;
            newNode = null;
            size.incrementAndGet();
            return Boolean.TRUE;
        } else if (tail == null && head == null) {
            node newNode = new node(t);
            head = newNode;
            tail = newNode;
            newNode = null;
            size.incrementAndGet();
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE;
        }

    }

    public T get() {
        if (head == null) {
            return null;
        }

        T t = (T) head.value;
        if (head == tail) {
            tail = head = null;
        } else {
            head = head.nex;
        }
        size.decrementAndGet();
        return t;
    }


    public int size() {

        return size.get();
    }
}

然后实现一个阻塞队列是持有上述队列，加入阻塞功能

package com.zwj;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyBlockQueue<T> {

    private MyQueue<T> myQueue;
    private final ReentrantLock myLock = new ReentrantLock();
    private final Condition notFull = myLock.newCondition();
    private final Condition notNull = myLock.newCondition();
    private final int length;

    public MyBlockQueue(int length) {
        this.length = length;

    }

    public void put(T t) {
        myLock.lock();
        if (myQueue == null) {
            this.myQueue = new MyQueue<>(t);
            myLock.unlock();
            return;
        }
        try {
            while (!myQueue.put(t, length)) {
                notFull.await();
            }
            notNull.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            myLock.unlock();
        }
    }

    public T take() {
        myLock.lock();
        T t = null;
        try {
            while (myQueue == null || (t = myQueue.get()) == null) {
                notNull.await();
            }
            notFull.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            myLock.unlock();
        }
        return t;
    }

}

最后 写一个main方法，建一个消费者线程池 和一个生产者线程池 来测试效果

package com.zwj;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String[] args) throws InterruptedException {
        // write your code here
        MyBlockQueue<Integer> queue = new MyBlockQueue<Integer>(10);
        ExecutorService consumers = Executors.newFixedThreadPool(10);
        ExecutorService produces = Executors.newFixedThreadPool(10);
           Thread consumer = new Thread(() -> {
            for (int i = 0; i < 500; i++) {
                consumers.execute(() -> {
                    int result = queue.take();
                    System.out.println("consumer:" + Thread.currentThread().getName() + Thread.currentThread().getId() + Thread.currentThread().getState() + " take Result: " + result);
                });
            }
        });
        Thread produce = new Thread(() -> {
            for (int i = 0; i < 500; i++) {
                int finalI = i;
                produces.execute(() -> {
                    queue.put(finalI);
                    System.out.println("produce:" + Thread.currentThread().getName() + Thread.currentThread().getId() + Thread.currentThread().getState()+ " put Result: " + finalI);
                });
            }
        });
        produce.start();

        consumer.start();
    }
}