jdk中队列的实现--阻塞队列和无阻塞队列

class QueueElement<T>{//队列节点
QueueElement<T> next=null;
QueueElement<T> prev=null;
T obj=null;
QueueElement(T var1){
this.obj=var1;
}
}
public class Queue<T>{//这是一个双向链表,是一个FIFO模型的队列
int length=0;
QueueElement<T> head=null;//头部
QueueElement<T> tail=null;//尾部
public Queue(){}
public synchronized void enqueue(T var1){//入队
QueueElement var2=new QueueElement(var1);
if(this.head==null){//队列为空
this.head=var2;
this.tail=var2;
this.length=1;
} else {
var2.next=this.head;
this.head.prev=var2;
this.head=var2;
this.length++;
}
this.notify();//唤醒其它线程
}
public T dequeue() throws InterruptedException(){//出队
return this.dequeue(0L);
}
public synchronized T dequeue(long var1){
while(this.tail==null){//队列为空时，等待
this.wait(var1);
}

QueueElement var3=this.tail;
this.tail=var3.prev;
if(this.tail==null){//队列只有一个元素
this.head=null;
} else {
this.tail.next=null;//释放这个节点
}
--this.length;
return var3.obj;
}
public synchronized boolean isEmpty(){
return this.tail==null;
}

public final synchronized Enumeration<T> elements(){
return new FIFOQueueElemerator(this);//获取一个枚举器
}
public final synchronized Enumeration<T> reverseElements(){
return new LIFOQueueElemerator(this);//获取一个后进先出的枚举器
}
}

final class FIFOQueueEnumerator<T> implements Enumeration<T>{
Queue<T> queue;
QueueElement<T> cursor;

FIFOQueueEnumerator(Queue queue){
this.queue=queue;
this.cursor=queue.tail;
}
public boolean hasMoreElements(){
return this.cursor!=null;
}

public T nextElement(){
Queue queue=this.queue;
synchronized(this.queue){
if(this.cursor!=null){
QueueElement qe=this.cursor;
this.cursor=this.cursor.prev;
return qe.obj;
}
}
}
}
final class LIFOQueueEnumerator<T> implements Enumeration<T> {
Queue<T> queue;
QueueElement<T> cursor;

LIFOQueueEnumerator(Queue<T> var1) {
this.queue = var1;
this.cursor = var1.head;
}

public boolean hasMoreElements() {
return this.cursor != null;
}

public T nextElement() {
Queue var1 = this.queue;
synchronized(this.queue) {
if(this.cursor != null) {
QueueElement var2 = this.cursor;
this.cursor = this.cursor.next;
return var2.obj;
}
}

throw new NoSuchElementException("LIFOQueueEnumerator");
}
}

static class Node<E> {
E item;
Node<E> next;

Node(E x) { item = x; }
}

public void put(E e) throws InterruptException{//入队
if(e ==null){
throw new NullPointerException();
}
int c=-1;
Node<E> node =new Node(e);
final ReentrantLock putLock=this.putLock;//private final ReentrantLock putLock = new ReentrantLock();默认是非公平锁
final AtomicInteger count=this.count;//线程安全的一个类，用于计数
putLock.lockInterruptibly();//获取锁，如果获取失败，则线程中断，等待机会被唤醒。
try{
while(count.get()==capacity){//private final int capacity;是一个成员变量，表示队列容量，默认为Integer.MAX_VALUE；
notFull.await();//当队列满了时，线程等。。待
}
enqueuw(node);//入队
c=count.getAndIncrement();//队列中元素数量自增1；
if(c+1<capacity){
notFull.signal();//还有可用容量
}
}finally{
putLock.unlock();//释放锁
}
if(c==0)
signalNotEmpty();
}

对于ReentrantLock,在并发编程中另外一文中详解。