Loading

Java阻塞队列

什么是阻塞队列

阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器里拿元素。
java中提供了七个阻塞队列,下面分别一一介绍。

ArrayBlockingQueue

介绍

一个数组实现的有界阻塞队列,此队列按照先进先出(FIFO)的原则对元素进行排序。支持公平锁和非公平锁。

特征

  • 基于数组实现,队列容量固定。
  • 先进先出,队列头是最先进队的元素,队列尾是最后进队的元素。
  • 存/取操作公用同一把锁(默认非公平锁ReentrantLock),无法实现真正意义上的存取并行。

分析

  • 构造方法

    由于ArrayBlockingQueue是有界队列,所以构造函数必须传入队列大小参数

    //接收一个整型的参数,这个整型参数指的是队列的长度
    public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }
    
    //boolean类型的参数是作为可重入锁的参数进行初始化,规定可重入锁是公平锁还是非公平锁,默认false
    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }
    
    //......
    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);
    
        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }
    
  • 通过下面的构造方法可以构建出ArrayBlockingQueue对象,构造方法中会实例化一些实例变量

    	//保存元素的数组
        final Object[] items;
    
    	//出队元素下标
        int takeIndex;
    
    	//入队元素下标
        int putIndex;
    
    	//统计队列元素个数
        int count;
    
    	//锁对象
        final ReentrantLock lock;
    
        //等待获取条件
        private final Condition notEmpty;
    
        //等待存放条件
        private final Condition notFull;
    
        /**
         * Shared state for currently active iterators, or null if there
         * are known not to be any.  Allows queue operations to update
         * iterator state.
         */
        transient Itrs itrs = null;
    

主要函数解析

1️⃣ add(E e)

  • add方法实际调用自己的 offer,参数不能为null。

  • 将 e 加到 ArrayBlockingQueue 当中,如果可以容纳返回true,否则抛出异常。

2️⃣ offer(E e)

  • 将 e 加到 ArrayBlockingQueue 当中,如果可以容纳返回true,否则返回false。

3️⃣ put(E e)

  • 将 e 加到 ArrayBlockingQueue 当中,如果没有空间,则调用此方法的线程会被阻断,直到有空间时继续。

4️⃣ poll()

  • 取走 ArrayBlockingQueue 排在首位的元素并返回。

5️⃣ poll(long timeout, TimeUnit unit)

  • 取走 ArrayBlockingQueue 排在首位的元素,若没有取到,则等待timeout规定的时间,取不到返回null。

6️⃣ take()

  • 取走 ArrayBlockingQueue 排在首位的元素,如果为空,阻断等待直到有新的元素加入。

7️⃣ remainingCapacity()

  • 返回队列剩余可用的大小。等于初始容量减去当前的size。

    注意 : 不能通过该方法来判断元素是否插入成功,因为有可能另外一个元素即将插入或删除一个元素。

LinkedBlockingQueue

介绍

一个由链表实现的有界阻塞队列,此队列按照先进先出(FIFO)的原则对元素进行排序。此队列的默认大小和长度为Integer.MAX_VALUE,所以默认创建的该队列有容量危险。

特征

  • 基于链表实现,默认容量大小 Integer.MAX_VALUE。
  • 存/取操作分别有独立的锁,可实现存/取并行执行。
  • 基于链表,新增和移除比数组快。但是每次新增/移除都会有Node对象的新增/移除,所以存在JVM GC的性能影响的可能。

分析

  • 构造方法

    //无参构造,默认长度为Integer.MAX_VALUE
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
    
    //接收一个整型的参数,这个整型参数指的是队列的长度    
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }
    
    //接受一个集合类型的参数,长度默认为Integer.MAX_VALUE,集合元素不能为null
    public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }
    
  • 通过查看源码可以发现有两个Node,分别存储首、尾节点,并且可以看到还有一个初始值得原子变量,用来记录队列的元素个数。另外还有两个 ReentrantLock 用来控制元素入队和出队的原子性。如下

        //容量大小,默认Integer.MAX_VALUE
        private final int capacity;
    
        //元素个数,线程安全
        private final AtomicInteger count = new AtomicInteger();
    
        //头节点
        transient Node<E> head;
    
        //尾节点
        private transient Node<E> last;
    
        //执行take,poll时获取该锁
        private final ReentrantLock takeLock = new ReentrantLock();
    
        //队列为空,执行出队(如take)的线程会使用该条件进行等待
        private final Condition notEmpty = takeLock.newCondition();
    
        //执行 put, offer 获取该锁
        private final ReentrantLock putLock = new ReentrantLock();
    
        //队列满了,执行入队(如put)的线程会使用该条件进行等待
        private final Condition notFull = putLock.newCondition();
    

主要函数解析

1️⃣ put(E e)

  • e元素为null则抛出NullPointerException异常。
  • 在队列尾部插入一个元素,如果有空闲则插入完成返回,如果队列已满则阻塞当前线程,直到队列有空闲插入成功后返回。

2️⃣ offer(E e)

  • e元素为null则抛出NullPointerException异常。
  • 在队列尾部插入一个元素,如果队列有空闲则返回true,如果队列已满则丢弃当前元素然后返回false。
  • 该方法是阻塞的。

3️⃣ poll()

  • 从队列头部获取并移除一个元素,如果队列为空则返回null,该方法是不阻塞的。

4️⃣ poll(long timeout, TimeUnit unit)

  • 取走 ArrayBlockingQueue 排在首位的元素,若没有取到,则等待timeout规定的时间,取不到返回null。

5️⃣ peek()

  • 获取队列头部的元素,但不移除它。该方法是不阻塞的。

6️⃣ take()

  • 获取队列头部的元素并从队列中移除它。
  • 如果队列为空则阻塞当前线程直到队列不为空然后返回元素。

7️⃣ remove(Object o)

  • 删除队列中指定元素的元素,有则返回true,没有则返回false。

8️⃣ size()

  • 获取当前队列元素个数。

PriorityBlockingQueue

介绍

PriorityBlockingQueue是带优先级的无界阻塞队列,每次出队都返回优先级最高或最低的元素。

默认使用对象的CompareTo方法提供比较规则,若需要自定义比较规则可自定义Comparators。

特征

  • 基于数组实现,队列容量最大为 Integer.MAX_VALUE - 8【减8是因为数组对象头,为了避免内存溢出】
  • 优先队列不允许空值,而且不支持non-compareable(不可比较对象),比如用户自定义的类。

分析

  • 构造方法

    //创建一个默认初始容量为11的PriorityBlockingQueue,根据元素的自然顺序对其排序
    public PriorityBlockingQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }
    
    //创建一个指定初始容量的PriorityBlockingQueue,根据元素的自然顺序对其排序
    public PriorityBlockingQueue(int initialCapacity) {
        this(initialCapacity, null);
    }
    
    //创建一个指定初始容量的PriorityBlockingQueue,根据指定的比较器对元素进行排列
    public PriorityBlockingQueue(int initialCapacity,Comparator<? super E> comparator) {
        //初始容量小于1会抛异常
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        //初始化锁
        this.lock = new ReentrantLock();
        //初始化条件变量
        this.notEmpty = lock.newCondition();
        //初始化比较器
        this.comparator = comparator;
        //初始化数组
        this.queue = new Object[initialCapacity];
    }
    
    //创建包含指定集合中的元素的PriorityBlockingQueue。
    //如果指定的集合是SortedSet或PriorityQueue,则该优先级队列将按照相同的顺序进行排序。
    //否则,该优先级队列将根据其元素的自然顺序进行排序。
    public PriorityBlockingQueue(Collection<? extends E> c) {
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        boolean heapify = true; // true if not known to be in heap order
        boolean screen = true;  // true if must screen for nulls
        if (c instanceof SortedSet<?>) {
            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
            this.comparator = (Comparator<? super E>) ss.comparator();
            heapify = false;
        }
        else if (c instanceof PriorityBlockingQueue<?>) {
            PriorityBlockingQueue<? extends E> pq =
                (PriorityBlockingQueue<? extends E>) c;
            this.comparator = (Comparator<? super E>) pq.comparator();
            screen = false;
            if (pq.getClass() == PriorityBlockingQueue.class) // exact match
                heapify = false;
        }
        Object[] a = c.toArray();
        int n = a.length;
        // If c.toArray incorrectly doesn't return Object[], copy it.
        if (a.getClass() != Object[].class)
            a = Arrays.copyOf(a, n, Object[].class);
        if (screen && (n == 1 || this.comparator != null)) {
            for (int i = 0; i < n; ++i)
                if (a[i] == null)
                    throw new NullPointerException();
        }
        this.queue = a;
        this.size = n;
        if (heapify)
            heapify();
    }
    
  • 队列中的初始化属性

        //默认数组容量
        private static final int DEFAULT_INITIAL_CAPACITY = 11;
    
        //分配数组的最大大小
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
        //存放队列元素
        private transient Object[] queue;
    
        //队列中元素数量
        private transient int size;
    
        //比较器,如果优先队列默认比较器,则为null
        private transient Comparator<? super E> comparator;
    
        //用于所有公共操作的锁
        private final ReentrantLock lock;
    
        //队列为空时的阻塞条件
        private final Condition notEmpty;
    
        //自旋锁,通过CAS获得
        private transient volatile int allocationSpinLock;
    
        //一个普通的PriorityQueue,仅用于序列化
        private PriorityQueue<E> q;
    

主要函数解析

1️⃣ offer(E e)

  • offer的作用是在队列中插入一个元素,由于是无界队列,所以会一直返回 true。

2️⃣ poll()

  • 获取队列内部堆树的根节点元素返回,并移除该元素。如果队列为空返回null。

3️⃣ put()

  • put 内部调用的是 offer()。将指定的元素插入这个优先级队列,由于该队列是无界的,这个方法永远不会阻塞。

4️⃣ take()

  • 获取队列内部堆树的根节点元素返回,并移除该元素。如果队列为空会阻塞,直到有线程调用 offer 方法添加成功后才会激活该线程。

5️⃣ size()

  • 返回队列中的元素数量。该方法在返回size前加了锁,以保证在调用size()时不会有其他线程入队和出队操作。另外由于size变量没有被Volatile修饰,所以加锁也保证了在多线程下size变量的内存可见性。

使用场景

VIP排队购票 : 用户购票的时候,根据不同的等级,优先放到队伍的前面,当存在票源的时候优先分配。

import java.util.concurrent.PriorityBlockingQueue;

/**
 * @author leizige
 */
class Ticket implements Comparable<Ticket> {
    private Integer level;
    private String ticketName;

    public Ticket(Integer level, String ticketName) {
        this.level = level;
        this.ticketName = ticketName;
    }

    @Override
    public int compareTo(Ticket o) {
        if (this.level > o.level) {
            return 1;
        }
        return -1;
    }

    @Override
    public String toString() {
        return this.level + "\t" + this.ticketName;
    }


}

/**
 * @author leizige
 */
public class PriorityBlockingQueueTest {
    public static void main(String[] args) throws InterruptedException {


        PriorityBlockingQueue<Ticket> ticketQueue = new PriorityBlockingQueue<>(11);
        ticketQueue.add(new Ticket(0, "level-0"));
        ticketQueue.add(new Ticket(4, "level-4"));
        ticketQueue.add(new Ticket(2, "level-2"));
        ticketQueue.add(new Ticket(1, "level-1"));
        ticketQueue.add(new Ticket(3, "level-3"));

        //TODO 返回该队列中元素的迭代器。迭代器不会以任何特定的顺序返回元素。
        // 返回的迭代器是弱一致的返回:一个遍历此队列中的元素的迭代器
//        Iterator<Ticket> iterator = ticketQueue.iterator();
//        while (iterator.hasNext()) {
//            System.err.println(iterator.next().toString());
//        }

        do {
            if (!ticketQueue.isEmpty())
                System.err.println(ticketQueue.take().toString());
        } while (!ticketQueue.isEmpty());

    }
}

DelayBlockingQueue

介绍

DelayQueue并发队列是一个无界阻塞延迟队列,队列中的每个元素都有个过期时间,当从队列获取元素时,只有过期元素才会出队列。队列头元素是最快要过期的元素。

特征

  • 不允许空元素。
  • 存储元素必须实现Delayed接口(Delayed接口继承了Comparable接口)。
  • 内部使用 PriorityQueue 存储数据。

分析

由于基于优先队列实现,但是它比较的是时间,可以根据需要来倒序或者正序排列。

  • 构造方法

    //初始化一个空的DelayQueue
    public DelayQueue() {}
    
    //创建一个DelayQueue,其中包含传入得集合元素
    public DelayQueue(Collection<? extends E> c) {
        this.addAll(c);
    }
    
  • 队列中的每个元素都要实现Delayed接口,由于每个元素都有一个过期时间,所以要实现获知当前元素剩下的过期时间的接口。由于队列内部使用优先队列来实现,所以要实现元素之间互相比较的接口。

    public interface Delayed extends Comparable<Delayed> {
    
        /**
         * Returns the remaining delay associated with this object, in the
         * given time unit.
         *
         * @param unit the time unit
         * @return the remaining delay; zero or negative values indicate
         * that the delay has already elapsed
         */
        long getDelay(TimeUnit unit);
    }
    

主要函数解析

1️⃣ offer(E e)

  • 插入元素到队列,如果元素为null则抛出NullPointerException异常,由于是无界队列,会一直返回true。插入的元素必须实现 Delayed接口。

2️⃣ take()

  • 获取并移除队列中延迟过期的元素,如果队列中没有过期元素则等待。

3️⃣ poll()

  • 获取并移除队头过期元素,如果没有过期元素返回null。

4️⃣ size()

  • 获取队列元素个数,包含过期和未过期的。

使用场景

  • 订单业务 :下单之后如果三十分钟之内没有付款就自动取消订单。
  • 短信通知 :下单成功六十秒后给用户发送短信通知。

简单实现

package queue;

import javax.validation.constraints.NotNull;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author leizige
 */
public class Work implements Delayed {

    /**
     * 数据
     */
    private String msg;
    /**
     * 延迟时间
     */
    private Long delay;
    /**
     * 到期时间
     */
    private Long expire;
    /***
     * 创建时间
     */
    private Long now;


    private Work() {
    }

    public Work(String msg, Long delay) {
        this.msg = msg;
        this.delay = delay;
        /* 到期时间 = 当前时间 + 延迟时间 */
        expire = System.currentTimeMillis() + delay;
        now = System.currentTimeMillis();
    }

    /**
     * 需要实现的接口,获得延迟时间 过期时间 - 当前时间
     */
    @Override
    public long getDelay(@NotNull TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * 延迟队列内部排序,当前时间的延迟时间 - 比较对象的延迟时间
     */
    @Override
    public int compareTo(@NotNull Delayed o) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public String toString() {
        return "work{" + "delay=" + delay +
                ", expire=" + expire +
                ", msg='" + msg + '\'' +
                ", now=" + now +
                '}';
    }
}
package queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;

/**
 * @author leizige
 */
public class DelayQueueTest {
    public static void main(String[] args) throws InterruptedException {


        BlockingQueue<Work> delayQueue = new DelayQueue<>();
        delayQueue.add(new Work("obj1", 1000L));
        delayQueue.add(new Work("obj3", 3000L));
        delayQueue.add(new Work("obj8", 8000L));
        delayQueue.add(new Work("obj2", 2000L));


        do {
            if (!delayQueue.isEmpty())
                System.err.println(delayQueue.take().toString());
        } while (!delayQueue.isEmpty());

    }
}

SynchronouseQueue

介绍

SynchronouseQueue 是一个不存储元素的阻塞队列。每一个put操作必须等待tack操作,否则不能添加元素。支持公平锁和非公平锁,默认情况下使用非公平性策略访问队列。

SynchronousQueue的一个使用场景是在线程池中,Executors.newCachedThreadPool()中就使用了SynchronousQueue,这个线程池根据需要(新任务到来时)创建新的线程,如果有空闲线程则会重复使用,线程空闲60s后会被回收。

分析

SynchronousQueue 可以看做一个传递者,负责把生产者线程处理的数据直接传递给消费者处理的线程,队列本身不存储任何元素,非常适合传递性的场景。并且 SynchronousQueue 的吞吐量高于 ArrayBlockingQueue 和 LinkedBlockingQueue。

  • 构造方法

    //创建不公平访问策略的SynchronousQueue
    public SynchronousQueue() {
        this(false);
    }
    
    //创建公平性访问的SynchronousQueue,如果fair==true,则等待的线程会以先进先出的顺序访问队列
    public SynchronousQueue(boolean fair) {
        transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
    }
    
  • SynchronousQueue 使用了内部类 Transfer 来转移数据,

    /**
    * Shared internal API for dual stacks and queues.
    */
    abstract static class Transferer<E> {
        /**
             * Performs a put or take.
             *
             * @param 如果e为null,则说明这是一个消费者线程,比如take操作
             *        如果e不为null,那么就是生产者线程,这个数据就是要交付的数据,比如put
             * @param timed if this operation should timeout
             * @param nanos the timeout, in nanoseconds
             * @return if non-null, the item provided or received; if null,
             *         the operation failed due to timeout or interrupt --
             *         the caller can distinguish which of these occurred
             *         by checking Thread.interrupted.
             */
        abstract E transfer(E e, boolean timed, long nanos);
    }
    

    SynchronousQueue 采用队列 TransferQueue 来实现公平性策略,采用堆栈 TransferStack 来实现非公平性策略。

  • TransferQueue ,TransferQueue 使用了 QNode 来作为队列节点

    /** Node class for TransferQueue. */
    static final class QNode {
        //队列中下一个节点
        volatile QNode next;          // next node in queue
        //数据项
        volatile Object item;         // CAS'ed to or from null
        //等待线程
        volatile Thread waiter;       // to control park/unpark
        //是否为数据标识
        final boolean isData;
    }
    

    TransferQueue 中主要有一下三个 QNode 对象

    //队列头
    transient volatile QNode head;
    //队列尾部
    transient volatile QNode tail;
    //指向一个已取消的节点,该节点可能未从队列中断开连接
    transient volatile QNode cleanMe;
    

    TransferQueue 构造方法

    TransferQueue() {
        QNode h = new QNode(null, false); // initialize to dummy node.
        head = h;
        tail = h;
    }
    
  • TransferStack ,TransferStack 使用了 SNode 来作为队列节点

    /** Node class for TransferStacks. */
    static final class SNode {
        //队列中下一个节点
        volatile SNode next;        // next node in stack
        //匹配的节点
        volatile SNode match;       // the node matched to this
        //等待线程
        volatile Thread waiter;     // to control park/unpark
        //数据项
        Object item;                // data; or null for REQUESTs
        int mode;
    }
    

    节点主要有以下三个状态

    //节点表示未满足的消费者
    static final int REQUEST    = 0;
    //节点表示未满足的生产者
    static final int DATA       = 1;
    //节点正在执行另一个未完成的数据或请求
    static final int FULFILLING = 2;
    
  • SynchronousQueue中的 put 、take都是依赖 TransferQueue或TransferTake的transfer方法实现的

    //将指定的元素添加到此队列中,并在必要时等待另一个线程接收它
    public void put(E e) throws InterruptedException {
        //不能为空
        if (e == null) throw new NullPointerException();
        //调用transfer方法
        if (transferer.transfer(e, false, 0) == null) {
            Thread.interrupted();
            throw new InterruptedException();
        }
    }
    
    public E take() throws InterruptedException {
        //调用transfer方法
        E e = transferer.transfer(null, false, 0);
        if (e != null)
            return e;
        Thread.interrupted();
        throw new InterruptedException();
    }
    

使用场景

插入数据的线程和获取数据的线程,交替执行

package queue;

import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

/**
 * @author leizige
 */
public class SynchronousQueueExample {


    static class SynchronousQueueProducer implements Runnable {

        private BlockingQueue<String> blockingQueue;

        public SynchronousQueueProducer(BlockingQueue<String> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    String data = UUID.randomUUID().toString();
                    System.out.println("Put:" + data);
                    blockingQueue.put(data);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    static class SynchronousQueueConsumer implements Runnable {
        private BlockingQueue<String> blockingQueue;

        public SynchronousQueueConsumer(BlockingQueue<String> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    String data = blockingQueue.take();
                    System.out.println(Thread.currentThread().getName()
                            + " take(): " + data);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String[] args) {
        final BlockingQueue<String> blockingQueue = new SynchronousQueue<>();

        SynchronousQueueProducer queueProducer = new SynchronousQueueProducer(blockingQueue);
        new Thread(queueProducer).start();

        SynchronousQueueConsumer queueConsumer_1 = new SynchronousQueueConsumer(blockingQueue);
        new Thread(queueConsumer_1).start();

        SynchronousQueueConsumer queueConsumer_2 = new SynchronousQueueConsumer(blockingQueue);
        new Thread(queueConsumer_2).start();

    }

}

应用场景

Executors.newCachedThreadPool()

    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to {@code execute} will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

LinkedTransferQueue

介绍

一个由链表结构组成的无界阻塞队列。相对于其他队列,LinkedTransferQueue队列多了transfer和tryTransfer方法。

......

LinkedBlockingDeque

介绍

一个由链表结构组成的双向阻塞队列。队列头部和尾部可以添加和移除元素,多线程并发时,可以将锁的竞争最多降到一半。

......

If you’re going to reuse code, you need to understand that code!
posted @ 2021-04-29 15:42  不颓废青年  阅读(46)  评论(0编辑  收藏  举报