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

队列有先进先出FIFO和后进先出LIFO两种模式
队列一般都采用链表实现
无阻塞队列：

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,在并发编程中另外一文中详解。