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();
            }
        }
    }
}