JUC集合类

向右看齐 2021-12-22 10:53 289阅读 0赞

**CopyOnWriteArrayList**

它相当于线程安全的ArrayList.  
1、使用场景：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。  
2、因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。  
3、迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作。  
4、使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

说明：  
1. CopyOnWriteArrayList实现了List接口，因此它是一个队列。  
2. CopyOnWriteArrayList包含了成员lock。每一个CopyOnWriteArrayList都和一个互斥锁lock绑定，通过lock，实现了对CopyOnWriteArrayList的互斥访问。  
3. CopyOnWriteArrayList包含了成员array数组，这说明CopyOnWriteArrayList本质上通过数组实现的。

下面从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList的原理进行说明。  
1. CopyOnWriteArrayList的“动态数组”机制 -- 它内部有个“volatile数组”(array)来保持数据。  
在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile数组”。  
这就是它叫做CopyOnWriteArrayList的原因！CopyOnWriteArrayList就是通过这种方式实现的动态数组；不过正由于它在“添加/修改/删除”数据时，  
都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList效率很低；但是单单只是进行遍历查找的话，效率比较高。

2. CopyOnWriteArrayList的“线程安全”机制 -- 是通过volatile和互斥锁来实现的。  
(01) CopyOnWriteArrayList是通过“volatile数组”来保存数据的。  
一个线程读取volatile数组时，总能看到其它线程对该volatile变量最后的写入；  
就这样，通过volatile提供了“读取到的数据总是最新的”这个机制的保证。  
(02) CopyOnWriteArrayList通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，  
再修改完毕之后，先将数据更新到“volatile数组”中，然后再“释放互斥锁”；这样，就达到了保护数据的目的。

**CopyOnWriteArraySet**  
它是线程安全的无序的集合，可以将它理解成线程安全的HashSet。  
HashSet是通过“散列表(HashMap)”实现的，而CopyOnWriteArraySet则是通过“动态数组(CopyOnWriteArrayList)”实现的。  
1、使用场景：Set 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。  
2、因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。  
3、迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等 操作。  
4、使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

说明：  
1、CopyOnWriteArraySet包含CopyOnWriteArrayList对象，它是通过CopyOnWriteArrayList实现的。  
而CopyOnWriteArrayList本质是个动态数组队列，所以CopyOnWriteArraySet相当于通过动态数组实现的“集合”！  
2、怎么实现不允许重复：CopyOnWriteArrayList额外提供了addIfAbsent()和addAllAbsent()这两个添加元素的API，  
通过这些API来添加元素时，只有当元素不存在时才执行添加操作！  
3、至于CopyOnWriteArraySet的“线程安全”机制，和CopyOnWriteArrayList一样，是通过volatile和互斥锁来实现的。

**HashMap, Hashtable, ConcurrentHashMap之间的关联如下：**  
HashMap是非线程安全的哈希表，常用于单线程程序中。  
Hashtable是线程安全的哈希表，它是通过synchronized来保证线程安全的；即，多线程通过同一个“对象的同步锁”来实现并发控制。  
Hashtable在线程竞争激烈时，效率比较低(此时建议使用ConcurrentHashMap)！  
因为当一个线程访问Hashtable的同步方法时，其它线程就访问Hashtable的同步方法时，可能会进入阻塞状态。  
ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来保证线程安全的。  
ConcurrentHashMap将哈希表分成许多片段(Segment)，每一个片段除了保存哈希表之外，本质上也是一个“可重入的互斥锁”(ReentrantLock)。  
多线程对同一个片段的访问，是互斥的；但是，对于不同片段的访问，却是可以同步进行的。

**ConcurrentHashMap**

原理：  
ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来实现的。ConcurrentHashMap中包括了“Segment(锁分段)数组”，  
每个Segment就是一个哈希表，而且也是可重入的互斥锁。  
第一，Segment是哈希表表现在，Segment包含了“HashEntry数组”，而“HashEntry数组”中的每一个HashEntry元素是一个单向链表。即Segment是通过链式哈希表。  
第二，Segment是可重入的互斥锁表现在，Segment继承于ReentrantLock，而ReentrantLock就是可重入的互斥锁。  
对于ConcurrentHashMap的添加，删除操作，在操作开始前，线程都会获取Segment的互斥锁；操作完毕之后，才会释放。  
而对于读取操作，它是通过volatile去实现的，HashEntry数组是volatile类型的，而volatile能保证“即对一个volatile变量的读，  
总是能看到（任意线程）对这个volatile变量最后的写入”，即我们总能读到其它线程写入HashEntry之后的值。

**ArrayBlockingQueue：**  
是数组实现的线程安全的有界的阻塞队列。  
线程安全是指，ArrayBlockingQueue内部通过“互斥锁”保护竞争资源，实现了多线程对竞争资源的互斥访问。  
而有界，则是指ArrayBlockingQueue对应的数组是有界限的。  
阻塞队列，是指多线程访问竞争资源时，当竞争资源已被某线程获取时，其它要获取该资源的线程需要阻塞等待；  
而且，ArrayBlockingQueue是按 FIFO（先进先出）原则对元素进行排序，元素都是从尾部插入到队列，从头部开始返回。  
说明：  
1、ArrayBlockingQueue内部是通过Object\[\]数组保存数据的，也就是说ArrayBlockingQueue本质上是通过数组实现的。  
ArrayBlockingQueue的大小，即数组的容量是创建ArrayBlockingQueue时指定的。  
2、ArrayBlockingQueue与ReentrantLock是组合关系，ArrayBlockingQueue中包含一个ReentrantLock对象(lock)。  
ReentrantLock是可重入的互斥锁，ArrayBlockingQueue就是根据该互斥锁实现“多线程对竞争资源的互斥访问”。  
而且，ReentrantLock分为公平锁和非公平锁，关于具体使用公平锁还是非公平锁，在创建ArrayBlockingQueue时可以指定；  
而且，ArrayBlockingQueue默认会使用非公平锁。  
3、ArrayBlockingQueue与Condition是组合关系，ArrayBlockingQueue中包含两个Condition对象(notEmpty和notFull)。  
而且，Condition又依赖于ArrayBlockingQueue而存在，通过Condition可以实现对ArrayBlockingQueue的更精确的访问  
\--(01)若某线程(线程A)要取数据时，数组正好为空，则该线程会执行notEmpty.await()进行等待；  
当其它某个线程(线程B)向数组中插入了数据之后，会调用notEmpty.signal()唤醒“notEmpty上的等待线程”。此时，线程A会被唤醒从而得以继续运行。  
\--(02)若某线程(线程H)要插入数据时，数组已满，则该线程会它执行notFull.await()进行等待；当其它某个线程(线程I)取出数据之后，会调用notFull.signal()唤醒“notFull上的等待线程”。此时，线程H就会被唤醒从而得以继续运行。

**LinkedBlockingQueue**：  
是一个单向链表实现的阻塞队列。该队列按 FIFO（先进先出）排序元素，新元素插入到队列的尾部，  
并且队列获取操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。  
此外，LinkedBlockingQueue还是可选容量的(防止过度膨胀)，即可以指定队列的容量。如果不指定，默认容量大小等于Integer.MAX\_VALUE。  
LinkedBlockingQueue是通过单链表实现的。  
(01) head是链表的表头。取出数据时，都是从表头head处插入。  
(02) last是链表的表尾。新增数据时，都是从表尾last处插入。  
(03) count是链表的实际大小，即当前链表中包含的节点个数。  
(04) capacity是列表的容量，它是在创建链表时指定的。  
(05) putLock是插入锁，takeLock是取出锁；notEmpty是“非空条件”，notFull是“未满条件”。通过它们对链表进行并发控制。  
LinkedBlockingQueue在实现“多线程对竞争资源的互斥访问”时，对于“插入”和“取出(删除)”操作分别使用了不同的锁。  
对于插入操作，通过“插入锁putLock”进行同步；对于取出操作，通过“取出锁takeLock”进行同步。  
此外，插入锁putLock和“非满条件notFull”相关联，取出锁takeLock和“非空条件notEmpty”相关联。通过notFull和notEmpty更细腻的控制锁。

\-- 若某线程(线程A)要取出数据时，队列正好为空，则该线程会执行notEmpty.await()进行等待；  
当其它某个线程(线程B)向队列中插入了数据之后，会调用notEmpty.signal()唤醒“notEmpty上的等待线程”。  
此时，线程A会被唤醒从而得以继续运行。 此外，线程A在执行取操作前，会获取takeLock，在取操作执行完毕再释放takeLock。  
\-- 若某线程(线程H)要插入数据时，队列已满，则该线程会它执行notFull.await()进行等待；  
当其它某个线程(线程I)取出数据之后，会调用notFull.signal()唤醒“notFull上的等待线程”。  
此时，线程H就会被唤醒从而得以继续运行。 此外，线程H在执行插入操作前，会获取putLock，在插入操作执行完毕才释放putLock。

**LinkedBlockingDeque**：  
LinkedBlockingDeque是双向链表实现的双向并发阻塞队列。该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)；并且，该阻塞队列是支持线程安全。  
此外，LinkedBlockingDeque还是可选容量的(防止过度膨胀)，即可以指定队列的容量。如果不指定，默认容量大小等于Integer.MAX\_VALUE。  
说明：  
1、继承于AbstractQueue，它本质上是一个支持FIFO和FILO的双向的队列。  
2、实现了BlockingDeque接口，它支持多线程并发。当多线程竞争同一个资源时，某线程获取到该资源之后，其它线程需要阻塞等待。  
3、通过双向链表实现的。  
3.1 first是双向链表的表头。  
3.2 last是双向链表的表尾。  
3.3 count是LinkedBlockingDeque的实际大小，即双向链表中当前节点个数。  
3.4 capacity是LinkedBlockingDeque的容量，它是在创建LinkedBlockingDeque时指定的。  
3.5 lock是控制对LinkedBlockingDeque的互斥锁，当多个线程竞争同时访问LinkedBlockingDeque时，某线程获取到了互斥锁lock，其它线程则需要阻塞等待，直到该线程释放lock，其它线程才有机会获取lock从而获取cpu执行权。  
3.6 notEmpty和notFull分别是“非空条件”和“未满条件”，是与lock绑定的条件，它们用于实现对多线程更精确的控制。

**ConcurrentLinkedQueue（尾插法）**  
线程安全的队列，它适用于“高并发”的场景。  
它是一个基于链接节点的无界线程安全队列，按照 FIFO（先进先出）原则对元素进行排序。队列元素中不可以放置null元素（内部实现的特殊节点除外）。  
说明：  
1. 继承于AbstractQueue。  
2. 内部是通过链表来实现的。它同时包含链表的头节点head和尾节点tail。ConcurrentLinkedQueue按照 FIFO（先进先出）原则对元素进行排序。元素都是从尾部插入到链表，从头部开始返回。  
3. 链表Node中的head,next,tail都是volatile类型，而且链表数据item的类型也是volatile。关于volatile，我们知道它的语义包含：“即对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入”。ConcurrentLinkedQueue就是通过volatile来实现多线程对竞争资源的互斥访问的。

转载于:https://www.cnblogs.com/raynnie/p/10833481.html