Java并发编程---并发队列

并发队列

---

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列非阻塞队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

阻塞队列与非阻塞队

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列.

ConcurrentLinkedDeque

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue.它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。

ConcurrentLinkedQueue重要方法:add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

	ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
	q.offer("one");
	q.offer("码云");
	q.offer("github");
	q.offer("百度");
	q.offer("QQ");
	//从头获取元素,删除该元素
	System.out.println(q.poll());
	//从头获取元素,不刪除该元素
	System.out.println(q.peek());
	//获取总长度
	System.out.println(q.size());

BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：

• 在队列为空时，获取元素的线程会等待队列变为非空。
• 当队列满时，存储元素的线程会等待队列可用。

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作
2. 当队列空了的时候进行出队列操作

// 生产者消费者
package consume;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


	
public class Product implements Runnable {

	private volatile boolean Flag=true;
	private AtomicInteger integer=new AtomicInteger();
	private BlockingQueue<String> queue;
	
	public Product(BlockingQueue<String> queue){
		this.queue=queue;
	}

	public void run() {
		try {
			System.out.println("生产者生产产品!");
			while(Flag) {
				String incrementAndGet = integer.incrementAndGet()+"";
				boolean offer = queue.offer("生产者生产的产品编号"+incrementAndGet,2,TimeUnit.SECONDS);
				if(!offer) {
					System.out.println("生产者生成失败!");
					return ;
				}
				System.out.println("生产者生产!"+incrementAndGet);
				Thread.sleep(1000);
			}
		} catch (Exception e) {
			
		}
		System.out.println(Thread.currentThread().getName() + ",生产者线程停止...");
		
	}

	public void stop() {
		this.Flag=false;
	}
}

package consume;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Consume implements Runnable{

	private volatile boolean Flag=true;
	private AtomicInteger integer=new AtomicInteger();
	private BlockingQueue<String> queue;
	
	public Consume(BlockingQueue<String> queue){
		this.queue=queue;
	}

	public void run() {
		try {
			System.out.println("消费者消费产品!");
			while(Flag) {
				
				String peek = queue.poll(5, TimeUnit.SECONDS);
				if (peek!=null) {
					System.out.println("消费者"+peek);
				}
				
				Thread.sleep(3000);
			}
			
		} catch (Exception e) {
			
		}
		System.out.println(Thread.currentThread().getName() + ",消费者线程停止...");
		
	}

	public void stop() {
		this.Flag=false;
	}
}

package consume;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class ProductConsume {

	public static void main(String[] args) throws InterruptedException {

		LinkedBlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>();
		Consume consume = new Consume(linkedBlockingQueue);
		Product product = new Product(linkedBlockingQueue);
		Thread thread1 = new Thread(consume);// sc
		Thread thread2 = new Thread(product); // xf
		
		thread2.start(); // xf
		thread1.start(); //sc
		Thread.sleep(1000*100);
		consume.stop();
		product.stop();

	}

}

ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。
ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

//初始化3个队列
ArrayBlockingQueue array = new ArrayBlockingQueue(3);
        array.add("张三");
        array.add("李四");
        array.add("大圣");
        // 添加阻塞队列
        boolean a=array.offer("王五",1, TimeUnit.SECONDS);
        System.out.println(a);
        //运行结果：false

LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。和ArrayBlockingQueue一样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(3);
linkedBlockingQueue.add("张三");
linkedBlockingQueue.add("李四");
linkedBlockingQueue.add("李四");
System.out.println(linkedBlockingQueue.size());

PriorityBlockingQueue

PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注
意，PriorityBlockingQueue中允许插入null对象。所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照我们对这个接口的实现来定义的。
另外，我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

SynchronousQueue

SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。