并发Queue

最新推荐文章于 2021-09-08 09:58:04 发布

旭出东方旭出东方旭出东方旭出东方旭出东方

最新推荐文章于 2021-09-08 09:58:04 发布

阅读量167

点赞数

分类专栏：多线程 java

本文链接：https://blog.csdn.net/u013720069/article/details/116306571

版权

java 同时被 2 个专栏收录

22 篇文章 1 订阅

订阅专栏

多线程

5 篇文章 0 订阅

订阅专栏

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

ConcurrentLinkedQueue

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

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

阻塞队列（BlockingQueue）

在网上找了几个阻塞队列的描述，可以加深理解一下：
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：
在队列为空时，获取元素的线程会等待队列变为非空。
当队列满时，存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

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

因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。
在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。 通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。 本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。
认识BlockingQueue
阻塞队列，顾名思义，首先它是一个队列，而一个队列在数据结构中所起的作用大致如下图所示：
从上图我们可以很清楚看到，通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；
在这里插入图片描述
常用的队列主要有以下两种：（当然通过不同的实现方式，还可以延伸出很多不同类型的队列，DelayQueue就是其中的一种）
　　先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。
　　后进先出（LIFO）：后插入队列的元素最先出队列，这种队列优先处理最近发生的事件。
多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地 解决他们之间的数据共享问题 。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）
下面两幅图演示了BlockingQueue的两个常见阻塞场景：
在这里插入图片描述
如上图所示：当队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列。

如上图所示：当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。

常见BlockingQueue

在了解了BlockingQueue的基本功能后，让我们来看看BlockingQueue家庭大致有哪些成员？
在这里插入图片描述

ArrayBlockingQueue

基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，其内部没实现读写分离，也就意味着生产和消费不能完全并行，长度是需要定义的，可以指定先进先出或者先进后出，也叫有界队列，在很多场合非常适合使用。
构造方法

//创造一个队列，指定队列容量就可以了，默认模式为非公平模式
public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
}
创造一个队列，指定队列容量和指定公平性
public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        //这里用的就是重入锁，
        //公平性通过fair来判断
        lock = new ReentrantLock(fair);
        //不为空条件队列，明显就是给消费者用
        notEmpty = lock.newCondition();
        //没有满条件队列，给生产者用
        notFull =  lock.newCondition();
}

重要属性

//底层数据结构，说明底层存储数据的数据结构是数组
private final E[] items;
//用来为下一个take/poll/remove的索引（出队）
private int takeIndex;
//用来为下一个put/offer/add的索引（入队）
private int putIndex;
//队列中元素的个数
private int count;
/** Main lock guarding all access */   
private final ReentrantLock lock;//锁
/** Condition for waiting takes */
private final Condition notEmpty;//等待出队的条件
/** Condition for waiting puts */
private final Condition notFull;//等待入队的条件

从这几个属性就能看出来，ArrayBlockingQueue的底层组成为：

数组
一个重入锁
两个条件队列
入队
add()方法

public boolean add(E e) {
    // 调用父类的add(e)方法
    return super.add(e);
}
public boolean add(E e) {
    // 调用offer(e)如果成功返回true，如果失败抛出异常
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

offer(e)方法入队

入参e为null，会抛空指针异常
元素插入到队尾（putIndex自增）
唤醒线程

生产者消费者模式

/**
 * 在队尾插入一个元素，
 * 如果队列没满，立即返回true；
 * 如果队列满了，立即返回false
 * 注意：该方法通常优于add(),因为add()失败直接抛异常
 */
public boolean offer(E e) {
    //检查存入的数据是否为null
    checkNotNull(e);        
    final ReentrantLock lock = this.lock;
    lock.lock();        
    try {            
        //如果数组满了，返回入队失败 
        if (count == items.length)                
            return false;            
        else {                
            //入队 
            enqueue(e);                
            return true;            
        }        
    } finally {            
        lock.unlock();        
    }
}
//如果存入的数据是null的会抛控指针异常 
private static void checkNotNull(Object v) {        
    if (v == null)   throw new NullPointerException();    
}
//putIndex是int类型，默认值就是0
private void enqueue(E x) {        
    final Object[] items = this.items;        
    //从下标为0的位置开始放入数据 
    items[putIndex] = x;        
    //如果putIndex等于数组大小，证明这是最后一个能存放的，然后把putIndex设置为0 
    //否则++putIndex 
    if (++putIndex == items.length){            
        putIndex = 0;        
    }
    //放入数据个数+1
    count++;
     /**
      * 唤醒一个线程
      * 如果有任意一个线程正在等待这个条件，那么选中其中的一个区唤醒。
      * 在从等待状态被唤醒之前，被选中的线程必须重新获得锁
      */
    notEmpty.signal();
}

带超时时间的offer，在队尾插入一个元素,，如果数组已满，则进入等待，直到出现以下三种情况：–>阻塞

被唤醒
等待时间超时
当前线程被中断

put方法入队

public void put(E e) throws InterruptedException {        
    checkNotNull(e);        
    final ReentrantLock lock = this.lock;  
    //加锁，如果线程中断了抛出异常
    lock.lockInterruptibly();        
    try {            
        while (count == items.length){   
            //这里就是阻塞了，要注意。如果运行到这里，
            //那么它会释放上面的锁，一直等到唤醒
            notFull.await();      
        }    
        //放入队列
        enqueue(e);        
    } finally {            
        lock.unlock();        
    }
}

小结

add(e)时如果队列满了则抛出异常；
offer(e)时如果队列满了则返回false；
put(e)时如果队列满了则使用notFull等待；
offer(e, timeout, unit)时如果队列满了则等待一段时间后如果队列依然满就返回false；
enqueue()利用放指针循环使用数组来存储元素；

出队

take方法出队

从头部出队
队中没有数据，等待被唤醒再取数据。

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    //加锁，如果线程中断了抛出异常
    lock.lockInterruptibly();        
    try {
        //队列中不存元素
        while (count == 0){  
            /*
             * 一直等待条件notEmpty，即被其他线程唤醒
             * （唤醒其实就是，有线程将一个元素入队了，然后调用notEmpty.signal()
             * 唤醒其他等待这个条件的线程，同时队列也不空了）
             */
            notEmpty.await();
        }
        //否则出队
        return dequeue();        
    } finally {            
        lock.unlock();        
    }    
}
private E dequeue() {
    final Object[] items = this.items;
    // 取取指针位置的元素
    E x = (E) items[takeIndex];
    // 把取指针位置设为null
    items[takeIndex] = null;
    // 取指针前移，如果数组到头了就返回数组前端循环利用
    if (++takeIndex == items.length)
        takeIndex = 0;
    // 元素数量减1
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    // 唤醒notFull条件
    notFull.signal();
    return x;
}

poll方法出队

太简单了，如果队列里没有数据，就直接返回null，否则从队列头部出队

public E poll() {        
    final ReentrantLock lock = this.lock;        
    lock.lock();        
    try {
        //如果队列里没有数据就直接返回null
        //否则从队列头部出队
        return (count == 0) ? null : dequeue();        
    } finally {            
        lock.unlock();       
    }   
}

remove方法

public E remove() {
    // 调用poll()方法出队
    E x = poll();
    if (x != null)
        // 如果有元素出队就返回这个元素
        return x;
    else
        // 如果没有元素出队就抛出异常
        throw new NoSuchElementException();
}

小结

remove()时如果队列为空则抛出异常；
poll()时如果队列为空则返回null；
take()时如果队列为空则阻塞等待在条件notEmpty上；
poll(timeout, unit)时如果队列为空则阻塞等待一段时间后如果还为空就返回null；
dequeue()利用取指针循环从数组中取元素；

LinkedBlockingQueue

基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操作的完全并行运行。他是一个无界队列。

PriorityBlockingQueue

基于优先级的阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定，也就是传入队列的对象必须实现Comparable接口），在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁，他也是一个无界队列。

public class Task implements Comparable<Task>{
  private int id ;
  private String name;
  public int getId() {
     return id;
  }
  public void setId(int id) {
     this.id = id;
  }
  public String getName() {
     return name;
  }
  public void setName(String name) {
     this.name = name;
  }
  @Override
  public int compareTo(Task task) {
     return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);  
  }
  public String toString(){
     return this.id + "," + this.name;
  }
}

public class UsePriorityBlockingQueue {
  public static void main(String[] args) throws Exception{
     PriorityBlockingQueue<Task> q = new PriorityBlockingQueue<Task>();
     Task t1 = new Task();
     t1.setId(3);
     t1.setName("id为3");
     Task t2 = new Task();
     t2.setId(4);
     t2.setName("id为4");
     Task t3 = new Task();
     t3.setId(1);
     t3.setName("id为1");
     Task t4 = new Task();
     t4.setId(8);
     t4.setName("id为8");
     Task t5 = new Task();
     t5.setId(6);
     t5.setName("id为6");
     //return this.id > task.id ? 1 : 0;
     q.add(t1);  //3
     q.add(t2);  //4
     q.add(t3);  //1
     q.add(t4);
     q.add(t5);
     // 1 3 4
     System.out.println("容器：" + q);
     System.out.println(q.take().getId());
     System.out.println("容器：" + q);
     System.out.println(q.take().getId());
     System.out.println("容器：" + q);
     System.out.println(q.take().getId());
     System.out.println("容器：" + q);
     System.out.println(q.take().getId());
     System.out.println(q.take().getId());
  }
}

运行结果:
容器：[1,id为1, 4,id为4, 3,id为3, 8,id为8, 6,id为6]
1
容器：[3,id为3, 4,id为4, 6,id为6, 8,id为8]
3
容器：[4,id为4, 8,id为8, 6,id为6]
4
容器：[6,id为6, 8,id为8]
6
8

DelayQueue

带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue中的元素必须实现Delayed接口，DelayQueue是一个没有大小限制的队列，应用场景很多，比如对缓存超时的数据进行移除、任务超时处理、空闲连接的关闭等等。

public class Wangmin implements Delayed {  
    private String name;  
    //身份证  
    private String id;  
    //截止时间  
    private long endTime;  
    //定义时间工具类
    private TimeUnit timeUnit = TimeUnit.SECONDS;
      
    public Wangmin(String name,String id,long endTime){  
        this.name=name;  
        this.id=id;  
        this.endTime = endTime;  
    }  
    public String getName(){  
        return this.name;  
    }  
    public String getId(){  
        return this.id;  
    }  
    /** 
     * 用来判断是否到了截止时间 
     */  
    @Override  
    public long getDelay(TimeUnit unit) { 
        //return unit.convert(endTime, TimeUnit.MILLISECONDS) - unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
     return endTime - System.currentTimeMillis();
    }  
    /** 
     * 相互批较排序用 
     */  
    @Override  
    public int compareTo(Delayed delayed) {  
     Wangmin w = (Wangmin)delayed;  
        return this.getDelay(this.timeUnit) - w.getDelay(this.timeUnit) > 0 ? 1:0;  
    }  
}

public class WangBa implements Runnable {  
    
    private DelayQueue<Wangmin> queue = new DelayQueue<Wangmin>();  
    public boolean yinye =true;  
      
    public void shangji(String name,String id,int money){  
        Wangmin man = new Wangmin(name, id, 1000 * money + System.currentTimeMillis());  
        System.out.println("网名"+man.getName()+" 身份证"+man.getId()+"交钱"+money+"块,开始上机...");  
        this.queue.add(man);  
    }  
    public void xiaji(Wangmin man){  
        System.out.println("网名"+man.getName()+" 身份证"+man.getId()+"时间到下机...");  
    }  
    @Override  
    public void run() {  
        while(yinye){  
            try {  
                Wangmin man = queue.take();  
                xiaji(man);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
    public static void main(String args[]){  
        try{  
            System.out.println("网吧开始营业");  
            WangBa siyu = new WangBa();  
            Thread shangwang = new Thread(siyu);  
            shangwang.start();  
              
            siyu.shangji("路人甲", "123", 1);  
            siyu.shangji("路人乙", "234", 10);  
            siyu.shangji("路人丙", "345", 5);  
        }  
        catch(Exception e){  
            e.printStackTrace();
        }  
    }  
}

在这里插入图片描述

SynchronousQueue

一种没有缓冲的队列，生产者生产的数据直接会被消费者获取并消费。

final SynchronousQueue<String> q = new SynchronousQueue<String>();
     Thread t1 = new Thread(new Runnable() {
       @Override
       public void run() {
          try {
            System.out.println("aaaaaaaaaa");
      `      System.out.println(q.take());
            System.out.println("bbbbbbbbbbb");
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
       }
     });
     t1.start();
     Thread.sleep(2000);
     Thread t2 = new Thread(new Runnable() {
       @Override
       public void run() {
          q.add("asdasd");
       }
     });
     t2.start();

参考链接：快速掌握并发编程—ArrayBlockingQueue 底层原理和实战

旭出东方旭出东方旭出东方旭出东方旭出东方

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
并发Queue

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自QueueConcurrentLinkedQueueConcurrentLinkedQueue：是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接点的无界线程安全队列。该队列的元素遵循先进先出的原则。头
复制链接

扫一扫