自定义一个简单的阻塞队列

通过LinkedList实现一个简单的阻塞队列，实现put和get方法

public class MyBlockingQueue<T> {
    private  LinkedList<T> linkedList = new LinkedList<>();

    private  AtomicInteger count = new AtomicInteger(0);

    private  int minSize = 0;

    private  int maxSize;

    private Object lock = new Object();

    public MyBlockingQueue(int maxSize){
        this.maxSize = maxSize;
    }

    public void put(T t){
        synchronized (lock){
            while(count.get() == maxSize){
                try {
                   lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            linkedList.add(t);
            count.incrementAndGet();
            System.out.println(" 元素 " + t + " 被添加 ");
            lock.notify();

        }
    }

    public T take(){
        T temp;
        synchronized (lock){
            while (count.get() == minSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            temp = linkedList.removeFirst();
            count.decrementAndGet();
            System.out.println(" 元素 " + temp + " 被消费 ");
            lock.notify();
        }
        return temp;
    }

    public int getSize(){
        return count.get();
    }

    public static void main(String[] args) {
        MyBlockingQueue<String> queue = new MyBlockingQueue<String>(5);
        queue.put("a");
        queue.put("b");
        queue.put("c");
        queue.put("d");
        queue.put("e");

        new Thread(new Runnable() {
            @Override
            public void run() {
                queue.put("+1");
                queue.put("+2");
            }
        }).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                queue.take();

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                queue.take();
            }
        }).start();

    }
}