## 常用的Queue实现类

### 线程安全的

#### 非阻塞队列

    public E poll() {
for (;;) {
for (Node<E> h = head, p = h, q;;) {
E item = p.item;

if (item != null && p.casItem(item, null)) { // CAS算法
// Successful CAS is the linearization point
// for item to be removed from this queue.
if (p != h) // hop two nodes at a time
updateHead(h, ((q = p.next) != null) ? q : p);
return item;
}
else if ((q = p.next) == null) {
return null;
}
else if (p == q)
else
p = q;
}
}
}

#### ArrayBlockingQueue

    public E poll() {
final ReentrantLock lock = this.lock;// 这个类中共用同一个锁
lock.lock();
try {
return (count == 0) ? null : extract();
} finally {
lock.unlock();
}
}

    public boolean offer(E e) {
if (e == null) throw new NullPointerException();
final AtomicInteger count = this.count;
if (count.get() == capacity)
return false;
int c = -1;
Node<E> node = new Node(e);
final ReentrantLock putLock = this.putLock;// 写锁
putLock.lock();
try {
if (count.get() < capacity) {
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
}
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
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.lock();
try {
if (count.get() > 0) {
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
}
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}

1、锁的实现不同
ArrayBlockingQueue实现的队列中的锁是没有分离的，即生产和消费用的是同一个锁，由此也意味着两者无法真正并行运行。
2、内部元素操作不同
ArrayBlockingQueue实现的队列中在生产和消费的时候，是直接将枚举对象插入或移除的，即不会产生任何额外的对象实例。
3、 队列初始化方式不同
ArrayBlockingQueue实现的队列中必须指定队列的大小。

#### PriorityBlockingQueue

    public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
int n, cap;
Object[] array;
while ((n = size) >= (cap = (array = queue).length))
tryGrow(array, cap);
try {
Comparator<? super E> cmp = comparator;
if (cmp == null)
siftUpComparable(n, e, array);
else
siftUpUsingComparator(n, e, array, cmp);// 支持优先级排序
size = n + 1;
notEmpty.signal();
} finally {
lock.unlock();
}
return true;
}

PriorityBlockingQueue里面存储的对象必须是实现Comparable接口。队列通过这个接口的compare方法确定对象的priority。

 PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();

for (Iterator iterator = queue.iterator(); iterator.hasNext();) {
}

Task [id=30]
Task [id=10]

#### 4.8.一些杂散但值得讨论的问题

2015年10月22日 10:32

#### Java并发编程知识点总结

2017-03-22 21:40:23

#### Java并发编程-并发编程知识点总结

2016-06-11 17:39:53

#### java程序员面试——Java并发编程知识点总结

2016-06-12 12:16:36

#### 关于Java并发编程的总结和思考

2015-03-27 10:36:10

#### 《JAVA并发编程实践》读书笔记（一）

2016-08-02 01:04:55

#### java并发编程总结（1）

2017-02-08 15:45:40

#### 《Java并发编程的艺术》读书笔记（一）

2015-08-27 11:36:18

#### 《java并发编程的艺术》读书笔记

2017-08-13 17:05:35

#### java并发编程面试宝典

2016-12-05 23:30:04

## 不良信息举报

java并发编程 之 Queue的一些总结