关于 concurrentHashMap 上的程序

Question

在一次采访中，面试官询问了并发 Hash Map 及其功能，我对此进行了详细解释。他说，在并发HashMap更新操作的情况下，ConcurrentHashMap只锁定Map的一部分，而不是整个Map。

于是他告诉我写一个简单的程序来证明，在更新操作期间，ConcurrentHashMap 只锁定了 Map 的一部分，而不是整个 Map。我无法做到这一点，所以请告诉我如何实现这一点。

Answer 1

面试官可能期待一个简单的答案，例如：

• 如果整个地图都为 get/put 操作同步，添加线程不会提高吞吐量，因为瓶颈将是同步块。然后，您可以使用 synchronizedMap 编写一段代码，表明添加线程没有帮助
• 因为映射使用多个锁，并且假设您的机器上有多个内核，添加线程将提高吞吐量

下面的例子输出如下：

同步一个线程：30
同步多线程：96
并发1个线程：219
并发多线程：142

因此您可以看到，在高争用（16 个线程）下，同步版本的速度要慢 3 倍以上，而并发版本的多线程速度几乎是单线程的两倍。

值得注意的是，ConcurrentMap 在单线程情况下具有不可忽略的开销。

这是一个非常人为的例子，所有可能的问题都归因于微基准测试（无论如何都应该丢弃第一个结果）。但它暗示了会发生什么。

public class Test1 {
    static final int SIZE = 1000000;
    static final int THREADS = 16;
    static final ExecutorService executor = Executors.newFixedThreadPool(THREADS);

    public static void main(String[] args) throws Exception{

        for (int i = 0; i < 10; i++) {
            System.out.println("Concurrent one thread");
            addSingleThread(new ConcurrentHashMap<Integer, Integer> ());
            System.out.println("Concurrent multiple threads");
            addMultipleThreads(new ConcurrentHashMap<Integer, Integer> ());
            System.out.println("Synchronized one thread");
            addSingleThread(Collections.synchronizedMap(new HashMap<Integer, Integer> ()));
            System.out.println("Synchronized multiple threads");
            addMultipleThreads(Collections.synchronizedMap(new HashMap<Integer, Integer> ()));
        }   
        executor.shutdown();
    }

    private static void addSingleThread(Map<Integer, Integer> map) {
        long start = System.nanoTime();
        for (int i = 0; i < SIZE; i++) {
            map.put(i, i);
        }
        System.out.println(map.size()); //use the result
        long end = System.nanoTime();
        System.out.println("time with single thread: " + (end - start) / 1000000);
    }

    private static void addMultipleThreads(final Map<Integer, Integer> map) throws Exception {
        List<Runnable> runnables = new ArrayList<> ();
        for (int i = 0; i < THREADS; i++) {
            final int start = i;
            runnables.add(new Runnable() {

                @Override
                public void run() {
                    //Trying to have one runnable by bucket
                    for (int j = start; j < SIZE; j += THREADS) {
                        map.put(j, j);
                    }
                }
            });
        }
        List<Future> futures = new ArrayList<> ();
        long start = System.nanoTime();
        for (Runnable r : runnables) {
            futures.add(executor.submit(r));
        }
        for (Future f : futures) {
            f.get();
        }
        System.out.println(map.size()); //use the result
        long end = System.nanoTime();
        System.out.println("time with multiple threads: " + (end - start) / 1000000);
    }
}