简单阻塞队列实现2

package com.security.dpi.das.fileprocess;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//简单阻塞队列实现2
public class SimpleBlockingQ
{
    public SimpleBlockingQ()
    {
        // TODO Auto-generated constructor stub
    }
//  Lock 替代了 synchronized 方法和语句的使用，Condition（await()，signalAll()）
//    替代了 Object （wait(), notifyAll()）监视器方法的使用。
//    synchronzied   Condition
//      lock();    
//      unlock();
//      wait();         await();
//      notify();       signal();
//      notifyAll();    signalAll();
//    ReentrantLock和Synchronized
//    Synchronized是Lock的一种简化实现，一个Lock可以对应多个
//    Condition，而synchronized把Lock和Condition合并了，一个
//    synchronized Lock只对应一个Condition，可以说Synchronized是
//    Lock的简化版本。
//    在JDK 5，Synchronized要比Lock慢很多，但是在JDK 6中，它们的
//    效率差不多。
//    不要在Lock和Condition上使用wait、notiffy、notifyAll方法！
   
    private Lock lock = new ReentrantLock();
//    一个锁可以创建多个Condition
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();
    private int maxLength = 10;
    private Queue<Object> q = new LinkedList<Object>();
   
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            if(q.size() == 0) {
//                要执行await操作，必须先取得该Condition的锁。
//                执行await操作之后，锁会释放。
//                被唤醒之前，需要先获得锁。
                notEmpty.await();
            }
            if(q.size() != maxLength) { //判断是否满，满就叫醒其他线程来取 没有满继续移除
                notFull.signalAll();  
            }
            return q.poll();
        } finally {
            lock.unlock();
        }
    }
   
    public void ofter() throws InterruptedException {
       lock.lock();
       try {
           if(q.size() > 0) {
//               要执行signal和signalAll操作，都必须先取
//               得该对象的锁。
               notEmpty.signalAll();
           }
           if(q.size() == maxLength) {
               notFull.await();   // 如果满了就阻塞 需要其他线程来取 没满就添加
           }
           q.add(notEmpty);
       } finally {
           lock.unlock();
       }
    }
}