并发队列

深入理解 JVM 原理
深入理解 JVM 原理
wangxiaoming

并发队列

并发包下面的并发容器中,ConcurrentLinkedQueue 这种 Concurrent 类型和的集合才真正代表并发。
并发队列

  • Concurrent 类型基于 lock-free ,常见的多线程访问场景,一般可以提供高吞吐量。
  • LinkedBlockingQueue 内部基于锁实现,提供了BlockingQueue等特性方法。

java.util.concurrent 包并发容器分类

  • Concurrent
  • CopyOnWrite
  • Blocking

Concurrent 类型集合

  1. Concurrent 类型没有类似 CopyOnWrite 之类容器相对较重的修改开销。
  2. Concurrent 往往提供了较低的遍历一致性,可以理解所谓的弱一致性,例如,当迭代器遍历时,如果容器发生修改,迭代器仍然可以继续遍历。
  3. 弱一致性的另外一个体现是, size 等操作准确性有限的,未必是100%准确。
  4. 读取的性能具有一定的不确定性

Java 集合中有个线程不安全的队列 LinkedList 是个 Deque。

ConcurrentLinkedDeque 和 LinkedBlockingQueue 区别

能够理解 ConcurrentLinkedQueue 和 LinkedBlockingQueue 的主要区别。
在常规队列操作基础上, Blocking意味着提供了特定的等待性操作。

阻塞队列 LinkedBlockingQueue

适用阻塞队列的好处,多线程操作共同的队列时不需要额外的同步。

  • void put(E e): 在队尾插入元素,方法在队列满的时候会阻塞直到有队列成员被消费
  • boolean offer(E e): 在队尾插入元素,方法在队列满的时候不会阻塞,直接返回 false
  • E take(): 取出并删除队列中的首元素,如果队列为空,会阻塞,直到有队列成员被放进来
  • E poll(): 取出并删除队列中的首元素,如果队列为空,则返回 null,不进行阻塞
  • E peek(): 取出第一个元素但是不删除它,没有就返回 null

非阻塞队列 ConcurrentLinkedQueue

允许多线程访问一个共同集合,可以使用 ConcurrentLinedQueue
Queue 中元素按 FIFO 原则进行排序。采用CAS 操作,来保证元素的一致性。

  • boolean offer(E e): 在队尾插入元素,不进行阻塞
  • E poll(): 取出并删除队列中的首元素,不进行阻塞
  • E peek(): 取出第一个元素但是不删除它,不进行阻塞

ConcurrentLinkedDeque 和 LinkedBlockingDeque。 Deque 的侧重点是支持对队列的头尾都信息插入和删除:

  • 尾部插入时需要的addLast(e)、 offerLast(e)。
  • 尾部删除所需要的removeLast()、 pollLast()。

阻塞队列 BlockingQueue 分类

  • ArrayBlockingQueue

ArrayBlockingQueue是最典型的的有界队列,其内部以final的数组保存数据,数组的大小就决定了队列的边界,所以我们在创建ArrayBlockingQueue时,都要指定容量,如:

public ArrayBlockingQueue(int capacity, boolean fair)
  • LinkedBlockingQueue

其行为和内部代码都是基于有界的逻辑实现的,只不过如果我们没有在创建队列时就指定容量,那么其容量限制就自动被设置为Integer.MAX_VALUE,成为了无界队列。

  • SynchronousQueue

每个删除操作都要等待插入操作,反之每个插入操作也都要等待删除动作。这个队列的容量是0。

  • PriorityBlockingQueue
    是无边界的优先队列,虽然严格意义上来讲,其大小总归是要受系统资源影响。

  • DelayedQueue 和 LinkedTransferQueue

都是无边界队列,就是 put 操作永远不会发生其他 BlockingQueue 阻塞的情况。

LinkedBlockingQueue 实现原理

/** Lock held by take, poll, etc */
private fnal ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private fnal Condition notEmpty = takeLock.newCondition();
/** Lock held by put, ofer, etc */
private fnal ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private fnal Condition notFull = putLock.newCondition();

LinkedBlockingQueue 改进了锁操作的力度,头,尾操作使用不同的锁,在通用的场景下,他的吞吐量相对要更好一些。

 public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {
                notEmpty.await();
            }
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

ArrayBlockingQueue take 实现原理

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

队列的使用场景

队列的典型使用场景是 生产者 -消费者 场景。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ConsumerProducer {
    public static final String EXIT_MSG = "Good bye!";

    public static void main(String[] args) {
        // 使用较小的队列,以更好地在输出中展示其影响
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }

    static class Producer implements Runnable {
        private BlockingQueue<String> queue;

        public Producer(BlockingQueue<String> q) {
            this.queue = q;
        }

        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                try {
                    Thread.sleep(5L);
                    String msg = "Message" + i;
                    System.out.println("Produced new item: " + msg);
                    queue.put(msg);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                System.out.println("Time to say good bye!");
                queue.put(EXIT_MSG);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Consumer implements Runnable {
        private BlockingQueue<String> queue;

        public Consumer(BlockingQueue<String> q) {
            this.queue = q;
        }

        @Override
        public void run() {
            try {
                String msg;
                while (!EXIT_MSG.equalsIgnoreCase((msg = queue.take()))) {
                    System.out.println("Consumed item: " + msg);
                    Thread.sleep(10L);
                }
                System.out.println("Got exit message, bye!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
程序员开发者社区

程序员开发者社区

wangxiaoming CSDN认证博客专家 架构 Spring Boot Redis
博客是很好的总结和记录工具,如果有问题,来不及回复,关注微信公众号:程序员开发者社区,获取我的联系方式,向我提问,也可以给我发送邮件,联系 1275801617@qq.com
©️2020 CSDN 皮肤主题: Age of Ai 设计师: meimeiellie 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值