并发编程-concurrent指南-阻塞队列-链表阻塞队列LinkedBlockingQueue

LinkedBlockingQueue是一个基于链表的阻塞队列。

由于LinkedBlockingQueue实现是线程安全的，实现了先进先出等特性，是作为生产者消费者的首选。

LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE。

此队列按 FIFO（先进先出）排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。

新元素插入到队列的尾部，并且队列检索操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，

它实现了BlockingQueue接口。

其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

作为开发者，我们需要注意的是，如果构造一个LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE），这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。

具体代码如下：

 

/**
 * 生产者
 */
public class Producer extends Thread{
    private LinkedBlockingQueue<Object> linkedBlockingQueue;
    public Producer(LinkedBlockingQueue<Object> linkedBlockingQueue){
        this.linkedBlockingQueue = linkedBlockingQueue;
    }

    @Override
    public void run() {
        int i = 0;
        while(i<12){
            try {
                System.out.println("currentThead:"+Thread.currentThread().getName()+".producer:"+i);
                linkedBlockingQueue.put(new Info(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i++;
        }
    }
}

 

import java.util.concurrent.LinkedBlockingQueue;

/**
 * 消费者
 */
public class Consumer extends Thread{
    private LinkedBlockingQueue<Info> linkedBlockingQueue;
    public Consumer(LinkedBlockingQueue<Info> linkedBlockingQueue){
        this.linkedBlockingQueue = linkedBlockingQueue;
    }

    @Override
    public void run() {
        while(true){
            try {
                Info obj = linkedBlockingQueue.take();
                System.out.println("consumer:"+obj.getI());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Info {
    private int i;
    public Info(int i){
        this.i = i;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }
}

/**

 * LinkedBlockingQueue 多用于任务队列
 * 适合 单生产者，单消费者
 *      多生产者，单消费者
 * ConcurrentLinkedQueue 多用于消息队列
 * 适合 单生产者 ，多消费者
 *      多生产者 ，多消费者
 *
 */
public class Main {
    public static void main(String[] args) {
        //声明队列:队列中只允许最多10条数据，超过等待执行
        LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(10);

        //三个生产者
        Producer producer1 = new Producer(linkedBlockingQueue);
        producer1.start();
        Producer producer2= new Producer(linkedBlockingQueue);
        producer2.start();
        Producer producer3= new Producer(linkedBlockingQueue);
        producer3.start();

        //一个消费者
        Consumer consumer = new Consumer(linkedBlockingQueue);
        consumer.start();
    }
}

 

源码地址：https://github.com/qjm201000/concurrent_linkedBlockingQueue.git

 

转载于:https://www.cnblogs.com/qjm201000/p/10143503.html