手写阻塞队列

package Method;

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

/**
 * Created by joyce on 2019/10/25.
 */
public class MyBlockingQueue<T> {

    private volatile MyLink<T> myLink = new MyLink<T>();

    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    private volatile int allow = 5;
    private volatile int length = 0;

    public static void main(String [] f) {

        MyBlockingQueue<Integer> myBlockingQueue = new MyBlockingQueue<>();
        for(int i=0; i<10; ++i) {
            final int j= i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    myBlockingQueue.push(j);
                }
            }).start();
        };

        try {
            System.out.println("sleep");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Integer t = myBlockingQueue.pop();
                    System.out.println("pop " + t);
                }
            }
        }).start();
    }

    public void push(T t) {

        try {
            lock.lock();
        //    if(length == allow)
            while (length == allow) {
                condition.await();
            }
            System.out.println("push " + t);
            myLink.add(t);
            ++length;
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public T pop() {
        try {
            lock.lock();
        //    if(length == 0)
            while (length == 0) {
                condition.await();
            }
            T t = myLink.get(0);
            myLink.remove(0);
            --length;
            condition.signalAll();
            return t;

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            lock.unlock();
        }
    }

}