基于synchronized实现的阻塞队列

 package com.lilei.pack09;

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

 public class MySyncQueue<T> {

     private Object[] ts;

     int pos = -1;

     public MySyncQueue(int size) {
         ts = new Object[size];
     }

     public synchronized void push(T t) throws InterruptedException {
         while (true) {
             if (pos + 1 < ts.length) {
                 ts[++pos] = t;
                 notifyAll();
                 System.out.println(Thread.currentThread().getName() + " push,currentSize=" + (pos + 1));
                 return;
             } else {
                 wait();
             }
         }
     }

     public synchronized T pop() throws InterruptedException {

         while (true) {
             if (pos >= 0) {
                 @SuppressWarnings("unchecked")
                 T t = (T) ts[pos--];

                 notifyAll();

                 System.out.println(Thread.currentThread().getName() + " pop,currentSize=" + (pos + 1));

                 return t;
             } else {
                 wait();
             }
         }

     }

     public static class Inner {

     }

     public static void main(String[] args) {
         ExecutorService es = Executors.newFixedThreadPool(30);

         final MySyncQueue<Inner> queue = new MySyncQueue<Inner>(15);

         int repeat = 1000;

         while (repeat-->0) {

             for (int i = 0; i < 15; i++) {
                 es.execute(new Runnable() {
                     public void run() {

                         try {
                             queue.pop();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                 });
             }

             for (int i = 0; i < 15; i++) {
                 es.execute(new Runnable() {
                     public void run() {

                         try {
                             queue.push(new Inner());
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                 });
             }

         }

         es.shutdown();
     }

 }