thread36 - ConcurrentHashMap

package com.neutron.t22;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CountDownLatch;

/**
 * 主要解说ConcurrentMap
 */
public class T221 {

    /**
     * 测试什么内容？
     * 创建1个容器，开启10个线程，每个线程向容器内加入10000个数据，来测试不同容器的执行时间
     */
    public static void main(String[] args) {
        //  高并发:ConcurrentHashMap在添加数据时，将整个对象分为16块，每次只锁定某1块
        //  如果不同的线程访问不同的块，那么就可以并发执行，不需要锁定整个对象。
        Map<String, String> map1 = new ConcurrentHashMap<>();

        //  高并发并且排序：ConcurrentSkipListMap使用跳表结构
        //  插入数据时效率低，但是排序后查询等操作效率高
        Map<String, String> map2 = new ConcurrentSkipListMap<>();
        Set<String> set2 = new ConcurrentSkipListSet<>();

        // HashTable默认加锁，效率低
        // HashTable在添加数据时，会锁定整个对象
        Map<String, String> map3 = new Hashtable<>();

        //  HashMap使用hash表实现
        Map<String, String> map4 = new HashMap<>();
        // TreeMap是tree实现
        TreeMap<String, String> map5 = new TreeMap<>();

        // 讨论的主要内容是在多线程的情况，哪个容器效率比较高
        Random random = new Random();
        // 100个线程的数组
        Thread[] threads = new Thread[100];
        // 计数器100
        CountDownLatch latch = new CountDownLatch(100);

        // 开始执行时间
        long start = System.currentTimeMillis();

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    // ConcurrentHashMap：576
                    // map1.put("ak" + random.nextInt(10000), "av" + random.nextInt(10000));
                    // ConcurrentSkipListMap：867
                    // map2.put("ak" + random.nextInt(10000), "av" + random.nextInt(10000));
                    // Hashtable：527
                    // map3.put("ak" + random.nextInt(10000), "av" + random.nextInt(10000));
                    // HashMap:407
                    // map4.put("ak" + random.nextInt(10000), "av" + random.nextInt(10000));
                    // TreeMap:569
                    map5.put("ak" + random.nextInt(10000), "av" + random.nextInt(10000));
                    latch.countDown();
                }
            });
        }

        Arrays.asList(threads).forEach(Thread::start);
        try {
            // 主线程等待
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 结束执行时间
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}
/**
 * 对于map和set的选择：本质上两者相同，key无非是k-v结构，set存放v而已
 * 如果不加锁，可以使用：HashMap、TreeMap、LinkHashMap
 * 如果加锁，可以使用HashTable，但是使用比较少，因为效率低
 * 在并发条件一般情况下，可以使用Collections.synchronizedXXX
 * 如果并发条件高：使用ConcurrentHashMap
 * 如果并发条件高并且要求排序：使用ConcurrentSkipListMap
 */