zoukankan      html  css  js  c++  java
  • CopyOnWriteArrayList(写入并复制) & CountDownLatch(闭锁)

    ConcurrentHashMap:

    ①Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。
    ② ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。

        对与多线程的操作,介于 HashMap 与 Hashtable 之间。

        内部采用“锁分段” 机制替代 Hashtable 的独占锁。进而提高性能。
    ③此包还提供了设计用于多线程上下文中的 Collection 实现:

         ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、

         CopyOnWriteArrayList 和 CopyOnWriteArraySet。

         当期望许多线程访问一个给 定 collection 时,ConcurrentHashMap 通常优于同步的 HashMap,

         ConcurrentSkipListMap 通常优于同步的 TreeMap。

         当期望的读数和遍历远远 大于列表的更新数时,CopyOnWriteArrayList 优于同步的 ArrayList。

         TestCopyOnWriteArrayList

    package com.aff.juc;
    import java.util.Iterator;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    /*
     *  CopyOnWriteArrayList/CopyOnWriteArraySet: "写入并复制" 
        注意:添加操作多时,效率低,因为每次添加时都会进行复制,
        开销非常大,并发迭代操作多时可以选择
      */
    public class TestCopyOnWriteArrayList {
        public static void main(String[] args) {
            HelloThread ht = new HelloThread();
            for (int i = 0; i < 10; i++) {
                new Thread(ht).start();
            }
        }
    }
    
    class HelloThread implements Runnable {
        //private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
        //CopyOnWriteArrayList写入并复制,每次写入时都会复制
        private static CopyOnWriteArrayList<String>  list = new CopyOnWriteArrayList<>();
        static {
            list.add("AA");
            list.add("BB");
            list.add("CC");
        }
    
        @Override
        public void run() {
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
                list.add("AA");
            }
        }
    }

    CountDownLatch:闭锁

    1.CountDownLatch 一个同步辅助类,

     在完成一组正在其他线程中执行的操作 之前, 它允许一个或多个线程一直等待。

    2.闭锁可以延迟线程的进度直到其到达终止状态,闭锁可以用来确保某些活
         动直到其他活动都完成才继续执行:
                                 ① 确保某个计算在其需要的所有资源都被初始化之后才继续执行;
                                 ②确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
                                 ③等待直到某个操作所有参与者都准备就绪再继续执行

    TestCountDownLatch

    package com.aff.juc;
    import java.util.concurrent.CountDownLatch;
    
    /*
     CountDownLatch:闭锁,在完成某些运算时,只有其他所有线程运算全部完成时,当前运算才会继续运行
     */
    public class TestCountDownLatch {
        public static void main(String[] args) {
            final CountDownLatch latch = new CountDownLatch(5);
            LetchDemo ld = new LetchDemo(latch);
            long start = System.currentTimeMillis();
            for (int i = 0; i < 5; i++) {
                new Thread(ld).start();
            }
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println("耗费时间:" + (end - start));
        }
    }
    
    class LetchDemo implements Runnable {
        private CountDownLatch latch;
    
        public LetchDemo(CountDownLatch latch) {
            this.latch = latch;
        }
    
        @Override
        public void run() {
            synchronized (this) {
                try {
                    for (int i = 0; i < 50000; i++) {
                        if (i % 2 == 0) {
                            System.out.println(i);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }
        }
    }
    All that work will definitely pay off
  • 相关阅读:
    02 查看线程的进程id
    ceshi
    unity atom 配置
    unity 扩展编辑器二 新建窗体
    unity 扩展编辑器一(修改编辑器名称)
    unity 计算投资回报
    Unity sendmessage发送多个参数
    unity 利用ugui 制作技能冷却效果
    unity 角色旋转
    unity 改变场景
  • 原文地址:https://www.cnblogs.com/afangfang/p/12631069.html
Copyright © 2011-2022 走看看