测试一下ConcurrentHashMap的性能

分手后的思念是犯贱 2022-11-28 13:32 132阅读 0赞

ConcurrentHashMap是线程安全的，HashTable也是线程安全，HashMap是非线程安全的，不过可以通过Collections封装成线程安全的，下面做个试验来验证下，三个集合在开启四个线程，每个线程对其进行50w次的操作，比较下会消耗多少时间。

@Test
    public void givenMaps_whenGetPut500KTimes_thenConcurrentMapFaster()
                throws Exception {
            Map<String, Object> hashtable = new Hashtable<>();
            Map<String, Object> synchronizedHashMap =
                    Collections.synchronizedMap(new HashMap<>());
            Map<String, Object> concurrentHashMap = new ConcurrentHashMap<>();
    
            long hashtableAvgRuntime = timeElapseForGetPut(hashtable);
            long syncHashMapAvgRuntime =
                    timeElapseForGetPut(synchronizedHashMap);
            long concurrentHashMapAvgRuntime =
                    timeElapseForGetPut(concurrentHashMap);
            logger.info("hashtableAvgRuntime = {},syncHashMapAvgRuntime = {},concurrentHashMapAvgRuntime={}",hashtableAvgRuntime,syncHashMapAvgRuntime, concurrentHashMapAvgRuntime );
    
            assertTrue(hashtableAvgRuntime > concurrentHashMapAvgRuntime);
            assertTrue(syncHashMapAvgRuntime > concurrentHashMapAvgRuntime);
        }
    
      private long timeElapseForGetPut(Map<String, Object> map)
                throws InterruptedException {
            ExecutorService executorService =
                    Executors.newFixedThreadPool(4);
            long startTime = System.nanoTime();
            for (int i = 0; i < 4; i++) {
                executorService.execute(() -> {
                    for (int j = 0; j < 500_000; j++) {
                        int value = ThreadLocalRandom
                                .current()
                                .nextInt(10000);
                        String key = String.valueOf(value);
                        map.put(key, value);
                        map.get(key);
                    }
                });
            }
            executorService.shutdown();
            executorService.awaitTermination(1, TimeUnit.MINUTES);
            return (System.nanoTime() - startTime) / 500_000;
        }

结果输出

hashtableAvgRuntime = 5327

syncHashMapAvgRuntime = 1460

concurrentHashMapAvgRuntime=492

可以看得出来ConcurrentHashMap在并发状态下效率很高