并发编程(7)-并发容器

Java中的常用位运算

操作符	名称	说明
&	位与	1 & 1 = 1; 0 & 0 = 0; 1 & 0 = 0;
|	位或	1 | 1 = 1; 0 | 0 = 0; 1 | 0 = 1;
^	位异或	1 ^ 1 = 0; 0 ^ 0 = 0; 1 ^ 0 = 1;
~	位非	~1 = 0; ~0 = 1;
>>	有符号右移	正数：高位补0; 负数：高位补1;
<<	有符号左移
>>>	无符号右移	正负数高位均补0

并发环境JDK1.7的HashMap扩容引发死循环分析

当往HashMap中put数据时，如果空间不足，则会对table扩容。这时候如果多个线程同时做put操作，则会引发出循环链表的数据结构。这时候如果get一个链表中没有的数据并且get的key正好散列匹配到这个链表，那么将会对这个循环链表做死循环查询，导致CPU飙升 。

源码1

源码2

源码3

源码4

源码5

代码步骤分析：

    前提假设：

    线程A、B

    Map原始数据{"3" :"abc", "7": "def", "5": "ghi"}

    HashMap的table大小为Entry<K,V>[] table = new Entry<K,V>[2];

1、假设原始数据有三个key：3、7、5，table数组原始长度为2。这三个key分别对table数组长度取模后都为1，即：3%2=1、7%2=1、5%2=1。即3、7、5这三个数据都存储在table[1]对应的链表上，并且有指针：3 -> 7 -> 5。

2、假如这时候两个线程A和B同时对HashMap做put操作并且table需要扩容，那么新table的大小将为4。见图 源码2 。

3、这时候A执行到图 源码3 的第593行被挂起了。即：e = 3;next = 7。

4、线程B正常循环扩容数据[图 源码3 newTable是线程独有的]：

    第一次循环：e = 3; next = 7; i = 3 % 4 = 3; e.next = newTable[i] = newTable[3] = null; newTable[3] = e = 3; e = 7;

    第二次循环：e = 7; next = 5; i = 7 % 4 = 3; e.next = newTable[i] = newTable[3] = 3; newTable[3] = e = 7 -> 3; e = 5;

    第三次循环：e = 5; next = null; i = 5 % 4 = 1; e.next = newTable[i] = newTable[1] = null; newTable[1] = e = 5; e = null;

    循环结束：table[1]上有5；table[3]上有 7 -> 3；

5、这时线程A被唤醒，那么线程A的循环结果如下：

    线程A已有第3步的：e = 3; next = 7;

    接着执行则为：int i = 3 % 4 = 3; e.next = newTable[i] = newTable[3] = null; newTable[3] = e = 3; e = 7;

    第二次循环：e = 7; next = 3; i = 7 % 4 = 3; e.next = newTable[3] = 3; newTable[3] = e = 7 -> 3; e = 3;

    第三次循环：e = 3; next = null; i = 3 % 4 = 3; e.next = newTable[3] = 7 -> 3; newTable[3] = e = 3 -> 7 -> 3;

   发现出现了循环链表

6、这时如果get(11)的话，11 % 4 = 3，所以要到table[3]对应的链表上查询，而table[3]对应的链表是循环链表并且没有key = 11的数据，就会导致线程一直死循环下去。

总结：

    当多个线程并发进行扩容时，一个线程先完成了扩容，将原来的Map链表重新散列，同时因为使用的是头插法，链表变成了倒序；然后下一个线程再扩容时，又进行重新散列，再次将链表变为正序；这时很有可能会形成环形链表，当get的元素不存在并且key散列后恰好匹配到这个链表时，就会造成死循环。

ConcurrentHashMap

    ConcurrentHashMap提供了一个实用的线程安全的

putIfAbsent()方法，如果传入的key对应的value已存在，就返回存在的value，不进行替换；如果不存在，就添加key和value，返回null。

ConcurrentHashMap map = new ConcurrentHashMap();

Object put = map.putIfAbsent("a", "123");

System.out.println(put);

System.out.println(map.get("a"));

Object put1 = map.putIfAbsent("a", "456");

System.out.println(put1);

System.out.println(map.get("a"));

/*
 * 输出结果
 * null
 * 123
 * 123
 * 123
*/

1.7中的ConcurrentHashMap

    ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。

    Segment是可重入锁，HashEntry用于存储数据。

    每个Segment中包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，由此可以看出，当要对HashEntry数组的数据进行修改时，需要先获得与它对应的Segment锁。

ConcurrentHashMap的构造函数：

    int initialCapacity：表示ConcurrentHashMap初始化容量，最大值不超过65536

    float loadFactor：负载因子阈值，用于控制大小调整。当每个箱子的平均元素数超过此阈值时，可以执行大小调整

    int concurrencyLevel：并发级别。他估计了并发更新线程的数量。实现执行内部大小调整以尝试容纳这么多线程。根据此值确认Segment数组大小，默认值是16。即可理解为程序运行时可以最多有16个线程执行写操作而不会产生锁竞争

    ConcurrentHashMap默认并发度为16，当用户在构造函数中设置并发度时，会使用大于等于该值的最小2幂指数作为实际并发度[如果设置并发度为17，实际并发度为32]。

    如果并发度值过小，会有严重的锁竞争问题；如果并发度值过大，原本同一个Segment内的访问会被散列到不同的Segment中，CPU cache命中率会下降而引起程序性能下降。

    segments数组的长度是通过concurrencyLevel计算得出的，为了能通过按位与的散列算法来定位数组索引，必须保证数组长度是2的N次方。

ConcurrentHashMap的弱一致性：

    由于 get(Object key) 和 contantsKey(Object key) 方法是没有加锁的，而且两个方法都是需要遍历链表来取得最终想要的数据；在遍历过程中，很可能其它线程已经把链表结构做了调整，导致这两个方法返回的不是时时数据；所以说ConcurrentHashMap是弱一致性的。

    下图为 size() 方法会导致线程阻塞的源码截图，contantsValue(Object value) 方法和 size() 方法相似：

    如果需要强一致性的场景，可以使用Collections.synchronizedMap()

1.8中的ConcurrentHashMap

特点：

取消了Segments属性，直接使用 transient volatile HashEntry<K, V>[] table 保存数据；采用table数组元素作为锁，缩小了锁粒度及减少并发冲突的概率，大量采用 CAS + synchronized 保证并发安全；

将原table数组+单向链表的数据结构改为了table数组+单向链表+红黑树结构；

    理想情况下table数组中每个队列的长度应该相近，查询的时间复杂度为O(n)；但有时还是会出现经过hash散列之后导致某个队列长度过长，当长度超过8（默认值）时，就将数据结构转为红黑树，那么查询的时间复杂度可降低到O(logN)。

    static final int TREEIFY_THRESHOLD = 8;// 链表转红黑树的阈值

    static final int UNTREEIFY_THRESHOLD = 6;// 红黑树转链表的阈值

    1.8 使用 Node（1.7是Entry）作为链表的数据结点，Node和Entry非常相似，同样包含了key，value，hash，next属性。红黑树使用的是TreeNode extends Node。因为继承自Node，所以TreeNode也有next指针。

    根据数组元素中，第一个结点的数据类型是Node还是TreeNode可以判断此位置数据结构是链表还是红黑树。

ForwardingNode

一个特殊的 Node 结点，hash 值为 -1，其中存储 nextTable 的引用。有 table 发生扩容的时候，ForwardingNode 发挥作用，作为一个占位符放在 table 中表示当前结点为 null 或者已经被移动。

sizeCtl

用来控制 table 的初始化和扩容操作。
负数代表正在进行初始化或扩容操作
   -1 代表正在初始化
   -N 表示有N-1 个线程正在进行扩容操作
    0 为默认值，代表当时的 table 还没有被初始化
正数表示初始化大小或 Map 中的元素达到这个数量时，需要进行扩容了。

get(Object key)

put(K key, V value)

size

在1.8版本中，扩容的时候就已经计算好了size，即上图的 addCount(1L, binCount); 方法。当调用 size() 时直接将计算好的结果返回。

在1.7版本中，当调用 size() 方法时才去计算。

HashTable

HashTable 容器使用synchronized 来保证线程安全，但在线程竞争激烈的情况下HashTable 的效率非常低下。因为当一个线程访问HashTable 的同步方法，其他线程也访问HashTable 的同步方法时，会进入阻塞或轮询状态。如线程1 使用put 进行元素添加，线程2 不但不能使用put 方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

总结

	HashTable	ConcurrentHashMap	HashMap
是否线程安全	是	是	否
效率	低	中	高
是否允许key为null	否	否	是
是否允许value为null	否	否	是
初始数组大小	11	16	16
扩容	扩大2倍+1	扩大2倍	扩大2倍
hash值	直接使用对象的hashCode	需要重新计算	需要重新计算
锁	synchronized使用一把锁锁住整个链表	1.7中使用分段锁[ReentrantLock + Segment + HashEntry]，锁粒度 Segment，数组+链表
		1.8中采用[CAS+synchronized+Node+红黑树]及分段锁，锁粒度Node，数组+链表+红黑树

ConcurrentSkipList系列

ConcurrentSkipListMap  有序 Map 线程安全

ConcurrentSkipListSet    有序 Set 线程安全

TreeMap 有序 Map 线程不安全

TreeSet   有序 Set 线程不安全

ConcurrentLinkedQueue

基于链表的无界线程安全队列。遵循先进先出原则；新元素插入到尾上，取元素从头开始取；可看作 LinkedList 的并发版本。

clq.add("a");

clq.offer("a");// 插到尾部

clq.peek();// 获取头元素并不移除

clq.poll();// 获取头元素并从队列移除

CopyOnWrite

CopyOnWriteArrayList

CopyOnWriteArraySet

适用于读多写少场景；

特点：会读到旧数据；内存开销大；

注意点：减少扩容开销，初始化时考虑好大小，避免写时扩容；每次写时都会复制，所以尽量使用批量添加；

队列 Queue

队尾插入、队头删除。又称为先进先出（FIFO—first in first out）线性表。

阻塞队列 BlockingQueue

阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列有空余位置；

阻塞的移除方法：当队列为空时，获取元素的线程会等待队列变为非空；

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。阻塞队列常用于生产者和消费者的场景。它相当于一个缓冲区，平衡了生产者和消费者的处理能力不均衡问题。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。

方法	抛出异常	返回特殊值	一直阻塞	超时退出
插入方法	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除方法	remove()	poll()	take()	poll(time, unit)
检查方法	element()	peek()	不可用	不可用

抛出异常：当队列满时，如果再插入元素，则抛出 IllegalStateException("Queuefull") 异常。当队列空时，从队列里获取元素会抛出 NoSuchElementException 异常；

返回特殊值：插入元素时，会返回元素是否插入成功，成功返回 true ；移除元素时，没有则返回 null ；

一直阻塞：当阻塞队列满时，如果生产者线程往队列里 put 元素，队列会一直阻塞生产者线程，直到队列可用或者响应中断退出；当队列为空时，消费者线程从队列里 take 元素，队列会阻塞消费者线程，直到队列不为空；

超时退出：当阻塞队列满时，如果生产者线程往队列里插入元素，队列会阻塞生产者线程一段时间，如果超过了指定时间，生产者线程就会退出；

常用阻塞队列

ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列；

LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列；

PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列；

DelayQueue：一个使用优先级队列实现的无界阻塞队列；

SynchronousQueue：一个不存储元素的阻塞队列；

LinkedTransferQueue：一个由链表结构组成的无界阻塞队列；

LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列；

以上阻塞队列都实现了 BlockingQueue 接口且线程安全。

有界无界

有界队列就是长度有限，满了以后生产者会阻塞，无界队列就是里面能放无数的元素而不会因为队列长度限制被阻塞，当然空间限制来源于系统资源的限制，如果处理不及时，导致队列越来越大，超出一定的限制致使内存超限，操作系统或者JVM 会把OOM kill 掉。
无界也会阻塞，是因为阻塞不仅仅体现在生产者放入元素时会阻塞，消费者拿取元素时，如果没有元素，同样也会阻塞。

ArrayBlockingQueue

用数组实现的有界阻塞队列。使用 Condition 来实现。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下线程非公平的访问队列，、公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞线程先访问队列。非公平性是对先等待的线程是非公平的，当队列可用时，阻塞的线程都可以争夺访问队列的资格，有可能先阻塞的线程最后才访问队列。构造函数可以配置。

初始化必须指定容器大小，可指定阻塞线程是否公平；

读写用同一把锁；

生产和消费时，直接将枚举对象插入或移除；

LinkedBlockingQueue

它是用单向链表实现的有界阻塞队列，采用对于的next构成链表的方式来存储对象。此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。

初始化如果不指定容器大小，则默认大小为 Integer.MAX_VALUE；

读写锁分离：对 put 和 offer 采用 putLock，对 take 和 poll 采用 takeLock，即为写锁和读锁，避免了读写时相互竞争锁的现象，因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，因此LinkedBlockingQueue在高并发读写操作都多的情况下，性能会比ArrayBlockingQueue好很多，在遍历以及删除元素时则要把两把锁都锁住；

生产和消费时，将枚举对象转换为 Node<E> 进行插入或移除，影响性能；

PriorityBlockingQueue

一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue 时，指定构造参数Comparator 来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。

DelayQueue

一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue 来实现。
队列中的元素必须实现Delayed 接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
DelayQueue 非常有用，可以将DelayQueue 运用在以下应用场景：

缓存系统的设计：可以用DelayQueue 保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue 中获取元素时，表示缓存有效期到了。还有订单到期，限时支付等。

public class DelayQueueTest {
    public static void main(String[] args) {
        Long now = System.currentTimeMillis();
        DelayQueue<User> delay = new DelayQueue<>();
        // 2秒后消费张三、3秒后消费王五、5秒后消费李四
        delay.put(new User(1, "张三", now + TimeUnit.SECONDS.toMillis(2)));
        delay.put(new User(2, "李四", now + TimeUnit.SECONDS.toMillis(5)));
        delay.put(new User(3, "王五", now + TimeUnit.SECONDS.toMillis(3)));

        Calendar calendar = Calendar.getInstance();
        System.out.println("开始时间：" + calendar.get(Calendar.HOUR)+"时"+calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒");
        while (0 != delay.size()) {
            User user = delay.poll();
            if (null != user) {
                calendar = Calendar.getInstance();
                System.out.println(JSONObject.toJSONString(user) + "  消费时间：" + calendar.get(Calendar.HOUR)+"时"+calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒");
            }
            SleepTools.ms(1);
        }
        System.out.println("数据已消费完！");
    }

    static class User implements Delayed {
        private Integer id;
        private String name;
        private Long time;

        public User(Integer id, String name, Long time){
            this.id = id;
            this.name = name;
            this.time = time;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return this.time - System.currentTimeMillis();
        }

        @Override
        public int compareTo(Delayed o) {
            return this.time - ((User)o).time <= 0 ? -1 : 1;
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

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

        public Long getTime() {
            return time;
        }

        public void setTime(Long time) {
            this.time = time;
        }
    }
}

运行结果：
开始时间：5时21分10秒
{"id":1,"name":"张三","time":1596014472745}  消费时间：5时21分12秒
{"id":3,"name":"王五","time":1596014473745}  消费时间：5时21分13秒
{"id":2,"name":"李四","time":1596014475745}  消费时间：5时21分15秒
数据已消费完！

SynchronousQueue

一个不存储元素的阻塞队列。每一个put 操作必须等待一个take 操作，否则不能继续添加元素。SynchronousQueue 可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue 的吞吐量高于 LinkedBlockingQueue 和 ArrayBlockingQueue。

LinkedTransferQueue

多了tryTransfer 和transfer 方法，
（1）transfer 方法
如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer 方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer 方法会将元素存放在队列的 tail 节点，并等到该元素被消费者消费了才返回。
（2）tryTransfer 方法
tryTransfer 方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回 false。和 transfer 方法的区别是 tryTransfer 方法无论消费者是否接收，方法立即返回，而 transfer 方法是必须等到消费者消费了才返回。

LinkedBlockingDeque

LinkedBlockingDeque 是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。
拥有addFirst、addLast、offerFirst、offerLast、peekFirst 和peekLast 等方法，以First 单词结尾的方法，表示插入、获取（peek）或移除双端队列的第一个元素。以Last 单词结尾的方法，表示插入、获取或移除双端队列的最后一个元素。
另外，插入方法add 等同于addLast，移除方法remove 等效于removeFirst。但是take 方法却等同于takeFirst，不知道是不是JDK 的bug，使用时还是用带有First和Last 后缀的方法更清楚。在初始化LinkedBlockingDeque 时可以设置容量防止其过度膨胀。另外，双向阻塞队列可以运用在“工作窃取”模式中。

 

_____个人笔记_____((≡^⚲͜^≡))_____欢迎指正_____