CopyOnwrite了解吗？

本文转载自微信公众号「Java极客技术」，作者鸭血粉丝 。转载本文请联系Java极客技术公众号。  

概念

CopyOnWrite 只是看字面意思就能看出来，就是在写入时复制，说得轻巧，写入时复制，具体是怎么实现的呢?

先来说说思想，具体怎么实现等下分析

CopyOnWrite 的思想就是：当向一个容器中添加元素的时候，不是直接在当前这个容器里面添加的，而是复制出来一个新的容器，在新的容器里面添加元素，添加完毕之后再将原容器的引用指向新的容器，这样就实现了写入时复制

你还记得在提到数据库的时候，一般都会说主从复制，读写分离吗?CopyOnWrite 的设计思想是不是和经常说的主从复制，读写分离如出一撤?

优缺点

了解概念之后，对它的优缺点应该就比较好理解了

优点就是，读和写可以并行执行，因为读的是原来的容器，写的是新的容器，它们之间互不影响，所以读和写是可以并行执行的，在某些高并发场景下，可以提高程序的响应时间

但是呢，你也看到了， CopyOnWrite 是在写入的时候，复制了一个新的容器出来，所以要考虑它的内存开销问题，又回到了在学算法时一直强调的一个思想：拿空间换时间

需要注意一下，它只保证数据的最终一致性。因为在读的时候，读取的内容是原容器里面的内容，新添加的内容是读取不到的

基于它的优缺点应该就可以得出一个结论：CopyOnWrite 适用于写操作非常少的场景，而且还能够容忍读写的暂时不一致 如果你的应用场景不适合，那还是考虑使用别的方法来实现吧

还有一点需要注意的是：在写入时，它会复制一个新的容器，所以如果有写入需求的话，最好可以批量写入，因为每次写入的时候，容器都会进行复制，如果能够减少写入的次数，就可以减少容器的复制次数

在 JUC 包下，实现 CopyOnWrite 思想的就是 CopyOnWriteArrayList & CopyOnWriteArraySet 这两个方法，本篇文章侧重于讲清楚 CopyOnWriteArrayList

CopyOnWriteArrayList

在 CopyOnWriteArrayList 中，需要注意的是 add 方法：

 
 
 
    
  
  
  
  1. public boolean add(E e) { 
    2. 
  
  
  
  2.         final ReentrantLock lock = this.lock; 
    3. 
  
  
  
  3.         // 在写入的时候,需要加锁,如果不加锁的话,在多线程场景下可能会被 copy 出 n 个副本出来 
    4. 
  
  
  
  4.         // 加锁之后,就能保证在进行写时,只有一个线程在操作 
    5. 
  
  
  
  5.         lock.lock(); 
    6. 
  
  
  
  6.         try { 
    7. 
  
  
  
  7.             Object[] elements = getArray(); 
    8. 
  
  
  
  8.             int len = elements.length; 
    9. 
  
  
  
  9.             // 复制原来的数组 
    10. 
  
  
  
  10.             Object[] newElements = Arrays.copyOf(elements, len + 1); 
    11. 
  
  
  
  11.             // 将要添加的元素添加到新数组中 
    12. 
  
  
  
  12.             newElements[len] = e; 
    13. 
  
  
  
  13.             // 将对原数组的引用指向新的数组 
    14. 
  
  
  
  14.             setArray(newElements); 
    15. 
  
  
  
  15.             return true; 
    16. 
  
  
  
  16.         } finally { 
    17. 
  
  
  
  17.             lock.unlock(); 
    18. 
  
  
  
  18.         } 
    19. 
  
  
  
  19.     } 
    20.

在写的时候需要加锁，但是在读取的时候不需要添加

因为读取的是原数组的元素，对新数组没有什么影响，加了锁反而会增加性能开销

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

举个例子：

 
 
 
    
  
  
  
  1. @Slf4j 
    2. 
  
  
  
  2. public class ArrayListExample { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     // 请求总数 
    5. 
  
  
  
  5.     public static int clientTotal = 5000; 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.     // 同时并发执行的线程数 
    8. 
  
  
  
  8.     public static int threadTotal = 200; 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.     private static List list = new ArrayList<>(); 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.     public static void  main(String[] args) throws Exception{ 
    13. 
  
  
  
  13.         ExecutorService executorService = Executors.newCachedThreadPool(); 
    14. 
  
  
  
  14.         final Semaphore semaphore = new Semaphore(threadTotal); 
    15. 
  
  
  
  15.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
    16. 
  
  
  
  16.         for (int i = 0; i < clientTotal; i++) { 
    17. 
  
  
  
  17.             final int count = i; 
    18. 
  
  
  
  18.             executorService.execute(()->{ 
    19. 
  
  
  
  19.                 try { 
    20. 
  
  
  
  20.                     semaphore.acquire(); 
    21. 
  
  
  
  21.                     update(count); 
    22. 
  
  
  
  22.                     semaphore.release(); 
    23. 
  
  
  
  23.                 } catch (Exception e) { 
    24. 
  
  
  
  24.                     log.error("exception",e); 
    25. 
  
  
  
  25.                 } 
    26. 
  
  
  
  26.                 countDownLatch.countDown(); 
    27. 
  
  
  
  27.             }); 
    28. 
  
  
  
  28.         } 
    29. 
  
  
  
  29.         countDownLatch.await(); 
    30. 
  
  
  
  30.         executorService.shutdown(); 
    31. 
  
  
  
  31.         log.info("size:{}",list.size()); 
    32. 
  
  
  
  32.     } 
    33. 
  
  
  
  33.     private static void update(int i){ 
    34. 
  
  
  
  34.         list.add(i); 
    35. 
  
  
  
  35.     } 
    36. 
  
  
  
  36. } 
    37.

上面是客户端请求 5000 次，有 200 个线程在同时请求，我使用的是 ArrayList 实现，咱们看下打印结果：

如果是线程安全的话，那么最后的结果应该是 5000 才对，多运行几次你会发现，每次程序的执行结果都是不一样的

如果是 CopyOnWriteArrayList 呢?

 
 
 
    
  
  
  
  1. @Slf4j 
    2. 
  
  
  
  2. public class CopyOnWriteArrayListExample { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     // 请求总数 
    5. 
  
  
  
  5.     public static int clientTotal = 5000; 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.     // 同时并发执行的线程数 
    8. 
  
  
  
  8.     public static int threadTotal = 200; 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.     private static List list = new CopyOnWriteArrayList<>(); 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.     public static void  main(String[] args) throws Exception{ 
    13. 
  
  
  
  13.         ExecutorService executorService = Executors.newCachedThreadPool(); 
    14. 
  
  
  
  14.         final Semaphore semaphore = new Semaphore(threadTotal); 
    15. 
  
  
  
  15.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
    16. 
  
  
  
  16.         for (int i = 0; i < clientTotal; i++) { 
    17. 
  
  
  
  17.             final int count = i; 
    18. 
  
  
  
  18.             executorService.execute(()->{ 
    19. 
  
  
  
  19.                 try { 
    20. 
  
  
  
  20.                     semaphore.acquire(); 
    21. 
  
  
  
  21.                     update(count); 
    22. 
  
  
  
  22.                     semaphore.release(); 
    23. 
  
  
  
  23.                 } catch (Exception e) { 
    24. 
  
  
  
  24.                     log.error("excepiton",e); 
    25. 
  
  
  
  25.                 } 
    26. 
  
  
  
  26.                 countDownLatch.countDown(); 
    27. 
  
  
  
  27.             }); 
    28. 
  
  
  
  28.         } 
    29. 
  
  
  
  29.         countDownLatch.await(); 
    30. 
  
  
  
  30.         executorService.shutdown(); 
    31. 
  
  
  
  31.         log.info("size:{}",list.size()); 
    32. 
  
  
  
  32.     } 
    33. 
  
  
  
  33.     private static void update(int i){ 
    34. 
  
  
  
  34.         list.add(i); 
    35. 
  
  
  
  35.     } 
    36. 
  
  
  
  36. } 
    37.

多运行几次，结果都是一样的：

由此可见， CopyOnWriteArrayList 是线程安全的

名称栏目：CopyOnwrite了解吗？
文章分享：http://www.shufengxianlan.com/qtweb/news17/451017.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

同城分类信息

app软件定制开发　　 　四川电信机房托管　　 　重庆服务器托管　　 　手机网站建设　　 　贵州义龙电信机房　　 　重庆移动机房托管　　 　高县网站建设　　 　瑞捷酒店用品　　 　网站解决方案　　 　平山县网站建设　　 　温江做网站　　 　成都网站建设　　 　成都网站建设　　 　德阳机房托管　　 　响应式网站设计　　 　网站建设改版　　 　seo优化排名　　 　重庆电商网站定制　　 　吉安网站建设　　 　企业网站建设公司