并发容器

ConcurrentHashMap

https://blog.csdn.net/zgsxhdzxl/article/details/96464184

ConcurrentSkipListMap 、ConcurrentSkipListSet

    采用跳表方式实现。它是一种以空间换时间的实现方式，再原链表的基础上，加了若干层索引，在某个节点插入的时候，会随机决定它是否成为上层索引。

 

ConcurrentLinkedQueue

无界阻塞队列，底层是链表结构

 

CopyOnWriteArrayList、CopyOnWriteArraySet

     写时复制容器。当往容器内添加元素的时候，并不直接操作原容器，而是复制一个新容器，在新容器内进行操作，完成之后，再将原容器的引用指向新的容器。这种适合读多写少的常景，例如白名单、黑名单等。

 

队列

常用方法

方法	抛出异常	返回值	阻塞	超时退出
插入	add	offer	put	offer
移除	remove	poll	take	poll
检查	element	peek	null	null

 

抛出异常：队列满时，往队列插入元素，会抛异常；当队列空时，从队列里获取元素也会抛出异常。

返回值：往队列中插入元素的时候，会返回元素是否插入成功；如果是移除元素，则从队列中取出元素，没有则返回null。

阻塞：队列满时，如果添加元素，会一直阻塞，直到队列可用或者中断线程。队列空的时候，如果从队列中移除，那么也会阻塞队列，直到队列不为空。

超时退出：队列满时，如果插入元素，会阻塞线程，过了超时间，线程就会退出。

 

常用阻塞队列

• ArrayBlockingQueue

数组结构的有界阻塞队列。必须设定初始大小。

• LinkedBlockingQueue

链表结构的有界双向阻塞队列。可以用在工作密取等场景。

• PriorityBlockingQueue

支持优先级排序的无界阻塞队列。默认情况下按照自然排序。

• DelayQueue

支持延时获取的无界阻塞队列。元素必须实现Delayed接口。可以用在限时订单、限时支付等场景。

//简单示例
public class DelayQueueDemo {

    public static void main(String[] args) {
        DelayQueue<Item<Order>> queue = new DelayQueue<>();
        Thread a = new Thread(()-> {
            Order ordeTb = new Order("1234"); //五秒过期
            Item<Order> aa = new Item<>(5000, ordeTb);
            queue.put(aa);
            Order ordeTb2 = new Order("2345");// 十秒过期
            Item<Order> a2 = new Item<>(10000, ordeTb2);
            queue.put(a2);
        });
        Thread b = new Thread(()-> {
            try {
                while (true) {
                    Item<Order> take = queue.take();
                    Order data = take.getData();
                    System.out.println(data.getName());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        a.start();
        b.start();

    }
    static class Item<T> implements Delayed {
        private long activeTime;
        private T data;
        public Item(long activeTime, T data) {
            this.data = data;
            this.activeTime = TimeUnit.MILLISECONDS.convert(activeTime,
                    TimeUnit.MILLISECONDS)+System.currentTimeMillis();//将传入的时长转换为超时的时刻
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(activeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            Long d = getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
            return d == 0 ? 0 : (d > 0 ? 1 : -1);
        }

        public long getActiveTime() {
            return activeTime;
        }
        public void setActiveTime(long activeTime) {
            this.activeTime = activeTime;
        }
        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }
    }

    static class Order {
        private String name;

        public Order(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

• SynchronousQueue

不存储元素的阻塞队列。put必须等待take

• LinkedTransferQueue

链表结构的无界阻塞队列。