Java并发容器J.U.C

J.U.Cjava.util.concurrent的简写,里面提供了很多线程安全的集合。

CopyOnWriteArrayList介绍

CopyOnWriteArrayList相比于ArrayList是线程安全的,字面意思是写操作时复制CopyOnWriteArrayList使用写操作时复制技术,当有新元素需要加入时,先从原数组拷贝一份出来。然后在新数组里面加锁添加,添加之后,将原来数组的引用指向新数组。

  1. public boolean add(E e) {
  2. final ReentrantLock lock = this.lock;
  3. lock.lock(); //加锁
  4. try {
  5. Object[] elements = getArray();
  6. int len = elements.length;
  7. Object[] newElements = Arrays.copyOf(elements, len + 1);
  8. newElements[len] = e;
  9. //引用指向更改
  10. setArray(newElements);
  11. return true;
  12. } finally {
  13. lock.unlock(); //释放锁
  14. }
  15. }

从上面的源码中得到CopyOnWriteArrayListadd操作是在加锁的保护下完成的。加锁是为了多线程对CopyOnWriteArrayList并发add时,复制多个副本,把数据搞乱。

  1. public E get(int index) {
  2. return get(getArray(), index);
  3. }

以上代码显示get是没有加锁的

如果出现并发get,会有以下3种情况。

  • 如果写操作未完成,那么直接读取原数组的数据;
  • 如果写操作完成,但是引用还未指向新数组,那么也是读取原数组数据;
  • 如果写操作完成,并且引用已经指向了新的数组,那么直接从新数组中读取数据。

CopyOnWriteArrayList多线程代码演示。

  1. package com.rumenz.task;
  2. import java.util.List;
  3. import java.util.concurrent.*;
  4. //线程安全
  5. public class CopyOnWrireArrayListExample {
  6. public static Integer clientTotal=5000;
  7. public static Integer threadTotal=200;
  8. private static List<Integer> list=new CopyOnWriteArrayList();
  9. public static void main(String[] args) throws Exception{
  10. ExecutorService executorService = Executors.newCachedThreadPool();
  11. final Semaphore semaphore=new Semaphore(threadTotal);
  12. final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
  13. for (int i = 0; i < clientTotal; i++) {
  14. final Integer j=i;
  15. executorService.execute(()->{
  16. try{
  17. semaphore.acquire();
  18. update(j);
  19. semaphore.release();
  20. }catch (Exception e){
  21. e.printStackTrace();
  22. }
  23. countDownLatch.countDown();
  24. });
  25. }
  26. countDownLatch.await();
  27. executorService.shutdown();
  28. System.out.println("size:"+list.size());
  29. }
  30. private static void update(Integer j) {
  31. list.add(j);
  32. }
  33. }
  34. //size:5000

CopyOnWriteArrayList使用场景

  • 由于在add的时候需要拷贝原数组,如果原数组内容比较多,比较大,可能会导致young gcfull gc

  • 不能用于实时读的场景,像拷贝数组,新增元素都需要时间,所以调用get操作后,有可能得到的数据是旧数据,虽然CopyOnWriteArrayList能做到最终一致性,但是没有办法满足实时性要求。

  • CopyOnWriteArrayList适合读多写少的场景,比如白名单,黑名单等场景

  • CopyOnWriteArrayList由于add时需要复制数组,所以不适用高性能的互联网的应用。

CopyOnWriteArraySet介绍

  1. public CopyOnWriteArraySet() {
  2. al = new CopyOnWriteArrayList<E>();
  3. }

CopyOnWriteArraySet底层是用CopyOnWriteArraySet来实现的。可变操作(add,set,remove等)都需要拷贝原数组进行操作,一般开销很大。迭代器支持hasNext(),netx()等不可变操作,不支持可变的remove操作,使用迭代器速度很快,并且不会与其它线程冲突,在构造迭代器时,依赖不变的数组快照。

CopyOnWriteArraySet多线代码演示

  1. package com.rumenz.task;
  2. import java.util.List;
  3. import java.util.Set;
  4. import java.util.concurrent.*;
  5. //线程安全
  6. public class CopyOnWrireArraySetExample {
  7. public static Integer clientTotal=5000;
  8. public static Integer threadTotal=200;
  9. private static Set<Integer> set=new CopyOnWriteArraySet();
  10. public static void main(String[] args) throws Exception{
  11. ExecutorService executorService = Executors.newCachedThreadPool();
  12. final Semaphore semaphore=new Semaphore(threadTotal);
  13. final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
  14. for (int i = 0; i < clientTotal; i++) {
  15. final Integer j=i;
  16. executorService.execute(()->{
  17. try{
  18. semaphore.acquire();
  19. update(j);
  20. semaphore.release();
  21. }catch (Exception e){
  22. e.printStackTrace();
  23. }
  24. countDownLatch.countDown();
  25. });
  26. }
  27. countDownLatch.await();
  28. executorService.shutdown();
  29. System.out.println("size:"+set.size());
  30. }
  31. private static void update(Integer j) {
  32. set.add(j);
  33. }
  34. }
  35. //size:5000

CopyOnWriteArraySet使用场景

  • 适用于set大小一般很小,读操作远远多于写操作的场景

ConcurrentSkipListSet

  1. public ConcurrentSkipListSet() {
  2. m = new ConcurrentSkipListMap<E,Object>();
  3. }

ConcurrentSkipListSet<E>jdk6新增的类,支持自然排序,位于java.util.concurrentConcurrentSkipListSet<E>都是基于Map集合的,底层由ConcurrentSkipListMap实现。

在多线程环境下,ConcurrentSkipListSet<E>add,remove,contains是线程安全的。但是对于批量操作addAll,removeAll,containsAll并不能保证原子操作,所以是线程不安全的,原因是addAll,removeAll,containsAll底层调用的还是add,remove,contains方法,在批量操作时,只能保证每一次的add,remove,contains是原子性的(即在进行add,remove,contains,不会被其它线程打断),而不能保证每一次批量操作都不会被其它线程打断,因此在addAllremoveAllretainAllcontainsAll操作时,需要添加额外的同步操作。

  1. public boolean addAll(Collection<? extends E> c) {
  2. boolean modified = false;
  3. for (E e : c)
  4. if (add(e))
  5. modified = true;
  6. return modified;
  7. }
  8. public boolean removeAll(Collection<?> c) {
  9. Objects.requireNonNull(c);
  10. boolean modified = false;
  11. Iterator<?> it = iterator();
  12. while (it.hasNext()) {
  13. if (c.contains(it.next())) {
  14. it.remove();
  15. modified = true;
  16. }
  17. }
  18. return modified;
  19. }
  20. public boolean containsAll(Collection<?> c) {
  21. for (Object e : c)
  22. if (!contains(e))
  23. return false;
  24. return true;
  25. }

ConcurrentSkipListSet代码演示

  1. package com.rumenz.task;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Set;
  5. import java.util.concurrent.*;
  6. //线程安全
  7. public class CopyOnWrireArrayListExample {
  8. public static Integer clientTotal=5000;
  9. public static Integer threadTotal=200;
  10. private static Set<Integer> set= new ConcurrentSkipListSet();
  11. public static void main(String[] args) throws Exception{
  12. ExecutorService executorService = Executors.newCachedThreadPool();
  13. final Semaphore semaphore=new Semaphore(threadTotal);
  14. final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
  15. for (int i = 0; i < clientTotal; i++) {
  16. final Integer j=i;
  17. executorService.execute(()->{
  18. try{
  19. semaphore.acquire();
  20. update(j);
  21. semaphore.release();
  22. }catch (Exception e){
  23. e.printStackTrace();
  24. }
  25. countDownLatch.countDown();
  26. });
  27. }
  28. countDownLatch.await();
  29. executorService.shutdown();
  30. System.out.println("size:"+set.size());
  31. }
  32. private static void update(Integer r) {
  33. set.add(r);
  34. }
  35. }
  36. //size:5000

ConcurrentHashMap

ConcurrentHashMapkeyvalue都不允许为null,ConcurrentHashMap针对读操作做了大量的优化。在高并发场景很有优势。

在多线程环境下,使用HashMap进行put操作会引起死循环,导致CPU利用率到100%,所以在多线程环境不能随意使用HashMap。原因分析:HashMap在进行put的时候,插入的元素超过了容量就会发生rehash扩容,这个操作会把原来的元素hash到新的扩容新的数组,在多线程情况下,如果此时有其它线程在进行put操作,如果Hash值相同,可能出现在同一数组下用链表表示,造成闭环,导致get的时候出现死循环,所以是线程不安全的。

HashTable它是线程安全的,它涉及到多线程的操作都synchronized关键字来锁住整个table,这就意味着所有的线程都在竞争同一把锁,在多线程环境下是安全的,但是效率很低。

HashTable有很多的优化空间,锁住整个table这么粗暴的方法可以变相的柔和点,比如在多线程的环境下,对不同的数据集进行操作时其实根本就不需要去竞争一个锁,因为他们不同hash值,不会因为rehash造成线程不安全,所以互不影响,这就是锁分离技术,将锁的粒度降低,利用多个锁来控制多个小的table,多线程访问容器里不同数据段的数据时,线程间就不会存在锁竞争,从而可以有效的提高并发访问效率,这就是ConcurrentHashMapJDK1.7版本的核心思想。

ConcurrentHashMap代码演示案例

  1. package com.rumenz.task;
  2. import java.util.Map;
  3. import java.util.Set;
  4. import java.util.concurrent.*;
  5. //线程安全
  6. public class ConcurrentHashMapExample {
  7. public static Integer clientTotal=5000;
  8. public static Integer threadTotal=200;
  9. private static Map<Integer,Integer> map=new ConcurrentHashMap<Integer,Integer>();
  10. public static void main(String[] args) throws Exception{
  11. ExecutorService executorService = Executors.newCachedThreadPool();
  12. final Semaphore semaphore=new Semaphore(threadTotal);
  13. final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
  14. for (int i = 0; i < clientTotal; i++) {
  15. final Integer j=i;
  16. executorService.execute(()->{
  17. try{
  18. semaphore.acquire();
  19. update(j);
  20. semaphore.release();
  21. }catch (Exception e){
  22. e.printStackTrace();
  23. }
  24. countDownLatch.countDown();
  25. });
  26. }
  27. countDownLatch.await();
  28. executorService.shutdown();
  29. System.out.println("size:"+map.size());
  30. }
  31. private static void update(Integer j) {
  32. map.put(j, j);
  33. }
  34. }
  35. //size:5000

ConcurrentSkipListMap

ConcurrentSkipListMap内部使用SkipList结构实现。跳表是一个链表,但是通过跳跃式的查找方式使得插入,读取数据时的时间复杂度变成O(log n)

跳表(SkipList):使用空间换时间的算法,令链表的每个结点不仅记录next结点位置,还可以按照level层级分别记录后继第level个结点。

图片alt

ConcurrentSkipListMap代码案例

  1. package com.rumenz.task;
  2. import java.util.Map;
  3. import java.util.concurrent.*;
  4. //线程安全
  5. public class ConcurrentSkipListMapExample {
  6. public static Integer clientTotal=5000;
  7. public static Integer threadTotal=200;
  8. private static Map<Integer,Integer> map=new ConcurrentSkipListMap<>();
  9. public static void main(String[] args) throws Exception{
  10. ExecutorService executorService = Executors.newCachedThreadPool();
  11. final Semaphore semaphore=new Semaphore(threadTotal);
  12. final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
  13. for (int i = 0; i < clientTotal; i++) {
  14. final Integer j=i;
  15. executorService.execute(()->{
  16. try{
  17. semaphore.acquire();
  18. update(j);
  19. semaphore.release();
  20. }catch (Exception e){
  21. e.printStackTrace();
  22. }
  23. countDownLatch.countDown();
  24. });
  25. }
  26. countDownLatch.await();
  27. executorService.shutdown();
  28. System.out.println("size:"+map.size());
  29. }
  30. private static void update(Integer j) {
  31. map.put(j, j);
  32. }
  33. }
  34. //size:5000

ConcurrentHashMapConcurrentSkipListMap的对比

  • ConcurrentHashMapConcurrentSkipListMap性能要好一些。
  • ConcurrentSkipListMapkey是有序的,ConcurrentHashMap做不到。
  • ConcurrentSkipListMap支持高并发,它的时间复杂度是log(N),和线程数无关,也就是说任务一定的情况下,并发的线程越多,ConcurrentSkipListMap的优势就越能体现出来。

返回笔记列表
入门小站