照著ArrayBlockingQueue自己實現了一些阻塞佇列，其原理就是生產者消費者關係，先實現了功能，一些細節（為什麼不用wite,notify 為什麼不用lock.lock()）暫時沒有去學習。

佇列程式碼：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * Created on 2017/8/31.
 */
public class MyBlockingQueue {
    final Object[] items=new Object[3
 
];
    final ReentrantLock lock=new ReentrantLock();
    private final Condition notFull;
    private static int num=-1;
    public MyBlockingQueue() {
        this.notFull = lock.newCondition();
    }
    public void put(Object item) throws InterruptedException {
//   如果滿了則開始阻塞
        lock.lockInterruptibly();
        try
 
 {
            while(items.length==num+1){
                System.out.println("queue is filled  and begin to wite");
                notFull.await();
            }
            num++;
            items[num]=item;
            System.out.println("put .."+item);
            System.out.println("put success and try to notify"
 
);
            notFull.signal();
        }finally {
            lock.unlock();
        }
    }
    public Object take(int index) throws InterruptedException {
    if (items.length<index){
        System.out.println("index is overflow...index="+index+",length="+items.length);
        return null;
    }
//    為空則阻塞
        lock.lockInterruptibly();
        try {
            while(num==-1){
                System.out.println("queue is empty and begin to wite");
                notFull.await();
            }
            Object result=items[num];
            items[num]=null;
            System.out.println("queue`s "+num+"is already remove");
            num--;
            System.out.println("try to notify");
            notFull.signal();
            return result;
        }finally {
            lock.unlock();
        }
    }
}

測試類程式碼：

/**
 * Created on 2017/8/31.
 */
public class Mytest {
    public static void main(String[] args) {
        final MyBlockingQueue queue=new MyBlockingQueue();
       new Thread(new Runnable() {
           @Override
           public void run() {
               for (int i = 0; i <10 ; i++) {
                   try {
                       queue.put(i);
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       }).start();
       new Thread(new Runnable() {
           @Override
           public void run() {
               for (int i = 0; i <10 ; i++) {
                   try {
                       queue.take(0);
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       }).start();
    }
}

列印結果：

put ..0
put success and try to notify
queue`s 0is already remove
try to notify
put ..1
put success and try to notify
put ..2
put success and try to notify
put ..3
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..4
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..5
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..6
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..7
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..8
put success and try to notify
queue is filled  and begin to wite
queue`s 2is already remove
try to notify
put ..9
put success and try to notify
queue`s 2is already remove
try to notify
queue`s 1is already remove
try to notify
queue`s 0is already remove
try to notify