- Java多线程总结之Queue

　　notFull.signal（）; //队列没满，当然可以解锁了

　　}

　　} finally {

　　putLock.unlock（）;

　　}

　　if （c == 0）

　　signalNotEmpty（）;//这个方法里发出了notEmpty.signal（）;

　　return c 》= 0;

　　}

　　public E poll（） {

　　final AtomicInteger count = this.count;

　　if （count.get（） == 0）

　　return null;

　　E x = null;

　　int c = -1;

　　final ReentrantLock takeLock = this.takeLock;出队当然用takeLock

　　takeLock.lock（）;

　　try {

　　if （count.get（） 》 0） {

　　x = dequeue（）;//出队

　　c = count.getAndDecrement（）;//队长度-1

　　if （c 》 1）

　　notEmpty.signal（）;//队列没空，解锁

　　}

　　} finally {

　　takeLock.unlock（）;

　　}

　　if （c == capacity）

　　signalNotFull（）;//这个方法里发出了notFull.signal（）;

　　return x;

　　}

　　看看源代码发现和上面ArrayBlockingQueue的很类似，关键的问题在于：为什么要用两个ReentrantLockputLock和takeLock？

　　我们仔细想一下，入队操作其实操作的只有队尾引用last，并且没有牵涉到head。而出队操作其实只针对head，和last没有关系。那么就是说入队和出队的操作完全不需要公用一把锁，所以就设计了两个锁，这样就实现了多个不同任务的线程入队的同时可以进行出队的操作，另一方面由于两个操作所共同使用的count是AtomicInteger类型的，所以完全不用考虑计数器递增递减的问题。

　　另外，还有一点需要说明一下：await（）和singal（）这两个方法执行时都会检查当前线程是否是独占锁的当前线程，如果不是则抛出java.lang.IllegalMonitorStateException异常。所以可以看到在源码中这两个方法都出现在Lock的保护块中。

　　-------------------------------我是分割线--------------------------------------

　　下面再来说说ConcurrentLinkedQueue，它是一个无锁的并发线程安全的队列。

　　以下部分的内容参照了这个帖子

　　对比锁机制的实现，使用无锁机制的难点在于要充分考虑线程间的协调。简单的说就是多个线程对内部数据结构进行访问时，如果其中一个线程执行的中途因为一些原因出现故障，其他的线程能够检测并帮助完成剩下的操作。这就需要把对数据结构的操作过程精细的划分成多个状态或阶段，考虑每个阶段或状态多线程访问会出现的情况。

　　ConcurrentLinkedQueue有两个volatile的线程共享变量：head，tail。要保证这个队列的线程安全就是保证对这两个Node的引用的访问（更新，查看）的原子性和可见性，由于volatile本身能够保证可见性，所以就是对其修改的原子性要被保证。

　　下面通过offer方法的实现来看看在无锁情况下如何保证原子性：

　　Java代码

　　public boolean offer（E e） {

　　if （e == null） throw new NullPointerException（）;

　　Node n = new Node（e， null）;

　　for （;;） {

　　Node t = tail;

　　Node s = t.getNext（）;

　　if （t == tail） { //------------------------------a

　　if （s == null） { //---------------------------b

　　if （t.casNext（s， n）） { //-------------------c

　　casTail（t， n）; //------------------------d

　　return true;

　　}

　　} else {

　　casTail（t， s）; //----------------------------e

　　}

　　}

　　}