1.ArrayDeque, （数组双端队列）
2.PriorityQueue, （优先级队列）
3.ConcurrentLinkedQueue, （基于链表的并发队列）
4.DelayQueue, （延期阻塞队列）（阻塞队列实现了BlockingQueue接口）
5.ArrayBlockingQueue, （基于数组的并发阻塞队列）
6.LinkedBlockingQueue, （基于链表的FIFO阻塞队列）
7.LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列）
8.PriorityBlockingQueue, （带优先级的*阻塞队列）
9.SynchronousQueue （并发同步阻塞队列）
SynchronousQueue 没有篮子，是一个现做现卖的原理。
Java 6的并发编程包中的SynchronousQueue是一个没有数据缓冲的BlockingQueue，生产者线程对其的插入操作put必须等待消费者的移除操作take，反过来也一样。
数据是在配对的生产者和消费者线程之间直接传递的，并不会将数据缓冲数据到队列中。可以这样来理解：生产者和消费者互相等待对方，握手，然后一起离开。
SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。
阻塞算法实现通常在内部采用一个锁来保证多个线程中的put()和take()方法是串行执行的。采用锁的开销是比较大的，还会存在一种情况是线程A持有线程B需要的锁，B必须一直等待A释放锁，即使A可能一段时间内因为B的优先级比较高，B一直占有时间片，A一直不能获得时间片，而得不到时间片运行。所以在高性能的应用中我们常常希望规避锁的使用。
放的线程要别的线程取走了才返回，否侧等待。取得时候为空也等待。一个放一个取一个放一个取这样执行下去。
package com.itmayiedu; import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit; public class SynchronousQueueDemo {
public static void main(String[] args) throws InterruptedException {
final SynchronousStack<String> queue = new SynchronousStack<String>(true);
// final SynchronousQueue1<String> queue = new SynchronousQueue1<String>(true); Thread put1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("put thread start");
try {
queue.put("put1" );
} catch ( Exception e) {
}
System.out.println("put thread end");
}
},"put1");
Thread put2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("put thread start");
try {
queue.put("put2" );
} catch (Exception e) {
}
System.out.println("put thread end");
}
},"put2");
Thread put3 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("put thread start");
try {
queue.offer("put3" ,,TimeUnit.SECONDS);
} catch (Exception e) {
}
System.out.println("put thread end");
}
},"put3");
Thread put4 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("put thread start");
try {
queue.put("put4" );
} catch (Exception e) {
}
System.out.println("put thread end");
}
},"put4"); Thread take1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("take thread start");
try {
System.out.println("take from putThread: " + queue.take());
} catch (Exception e) {
}
System.out.println("take thread end");
}
},"take1");
Thread take2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("take thread start");
try {
System.out.println("take from putThread: " + queue.take());
} catch (Exception e) {
}
System.out.println("take thread end");
}
},"take2");
Thread take3 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("take thread start");
try {
System.out.println("take from putThread: " + queue.take());
} catch (Exception e) {
}
System.out.println("take thread end");
}
},"take3"); put1.start();
put2.start();
put3.start();
put4.start();
// take1.start();
// take2.start();
// take3.start();
}
}
public class NativeSynchronousQueue<E> {
boolean putting = false;
E item = null;
public synchronized E take() throws InterruptedException {
while (item == null)//没有元素就等
wait();
E e = item;
item = null;
notifyAll();//目的是唤醒放的线程，有可能唤醒了取的线程（继续等）
return e;
}
public synchronized void put(E e) throws InterruptedException {
if (e == null)
return;
while (putting)//有人在放，就等待
wait();//此处唤醒，继续等待
putting = true;
item = e;
notifyAll();//目的是唤醒取的线程，有可能唤醒了放的线程（继续等），有可能唤醒了自己（继续等）
while (item != null)//没人取走，就等待
wait();
putting = false;
notifyAll();
}
}
public class SemaphoreSynchronousQueue<E> {
E item = null;
Semaphore sync = new Semaphore();
Semaphore send = new Semaphore();
Semaphore recv = new Semaphore();//一定先release再acquire
public E take() throws InterruptedException {
recv.acquire();//放线程put好了，取的线程就可以取
E x = item;
sync.release();//取完了，当前放的线程可以走了，
send.release();//取完了，下个线程可以放了，
return x;
}
public void put (E x) throws InterruptedException{
send.acquire();//只能一个线程放，防止item不安全，
item = x;
recv.release();//我已经put好了，取的线程可以取了，
sync.acquire();//取完了，当前放的线程可以走了，
}
}
放的线程1放，放好了，通知取的线程1取，取完了通知放的线程2放，放好了，通知取线程2去取，依次。。
在多核机器上，上面方法的同步代价仍然较高，操作系统调度器需要上千个时间片来阻塞或唤醒线程，而上面的实现即使在生产者put()时已经有一个消费者在等待的情况下，阻塞和唤醒的调用仍然需要。
上面的实现是有一个位置可以去放，但是放的线程要等到取走了才能返回。
SynchronousQueue是生产线程将东西直接交给消费线程。不需要容器。
Java 6的SynchronousQueue的实现采用了一种性能更好的无锁算法 — 扩展的“Dual stack and Dual queue”算法。性能比Java5的实现有较大提升。竞争机制支持公平和非公平两种：非公平竞争模式使用的数据结构是后进先出栈(Lifo Stack)；公平竞争模式则使用先进先出队列（Fifo Queue），性能上两者是相当的，一般情况下，Fifo通常可以支持更大的吞吐量，但Lifo可以更大程度的保持线程的本地化。
这个算法的特点就是任何操作都可以根据节点的状态判断执行，而不需要用到锁。
其核心接口是Transfer，生产者的put或消费者的take都使用这个接口，根据第一个参数来区别是入列（栈）还是出列（栈）。
负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue的吞吐量高于ArrayBlockingQueue和LinkedBlockingQueue。
abstract static class Transferer<E> {
abstract E transfer(E e, boolean timed, long nanos);
}
从注释中可以看出，该类的唯一一个transfer方法是通过参数e来区分调用方法的是一个生产者线程还是一个消费者线程，如果e为null，则说明这是一个消费者线程，比如一个take操作，如果e不为null，那么就是一个生产者线程，这个数据就是这个线程需要交付的数据，比如一个put操作。
SynchronousQueue采用队列TransferQueue来实现公平性策略，采用堆栈TransferStack来实现非公平性策略，SynchronousQueue的put、take操作都是委托这两个类来实现的，我们下面先来了解一下这两个类。
最后分析的SynchronousQueue是最为复杂的阻塞队列。
生产者先进来排队，消费者来了不排队（把生产者弄出去），消费者多了排队，生产者来了不排队（把消费者弄出去）