手撕阻塞队列

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

public class MyQueue<T> {


    public MyQueue(Integer capacity) {
        this.capacity = capacity;
    }

    private Integer capacity;

    private volatile int size = 0;

    private LinkedList<T> container = new LinkedList<>();

    private Lock lock = new ReentrantLock();

    private Condition fullCondition = lock.newCondition();

    private Condition emptyCondition = lock.newCondition();

    public void add(T t) {
        lock.lock();
        try {
            while (capacity.equals(size)) {
                System.out.println("对象满了");
                try {
                    fullCondition.await();
                } catch (InterruptedException e) {
                    fullCondition.signal();
                    e.printStackTrace();
                }
            }
            size++;
            emptyCondition.signal();
            container.add(t);
        } finally {
            lock.unlock();
        }
    }

    public T get() {
        lock.lock();
        try {
            while (size == 0) {
                try {
                    emptyCondition.await();
                } catch (InterruptedException e) {
                    emptyCondition.signal();
                    e.printStackTrace();
                }
            }
            size--;
            fullCondition.signal();
            return container.remove(0);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        MyQueue<String> queue = new MyQueue<String>(10);
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                queue.add("元素" + i);
                System.out.println("添加元素" + i);
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for(;;){
                System.out.println("消费：" + queue.get());
                try {
                    Thread.sleep(800);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
    }

}