简单阻塞队列实现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();
}
}
}