HashTable、HashMap、Synchronized、ConcurrentHashMap性能测试分析

最新推荐文章于 2024-06-22 17:30:23 发布
最新推荐文章于 2024-06-22 17:30:23 发布
阅读量386 收藏 1
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w13485673086/article/details/105213554
版权

目的

本文目的是为了对HashTable、HashMap、SynchronizedMap、ConcurrentHashMap做一个性能测试，以比较理论与实践的差距

方法

首先我准备了一个Junit测试类，可以配置不同线程并发数，以及插入到Map中的数据量大小。具体代码如下：

package com.ethan.juc.container;

import org.junit.BeforeClass;
import org.junit.Test;

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

public class TestCollection {

    // 待插入数据总量
    static int count = 1000000;
    // 并发线程数
    static final int THREAD_COUNT = 10;
    // 待插入的key
    static UUID[] keys = new UUID[count];
    // 待插入的value
    static UUID[] values = new UUID[count];
    // 每个线程负责插入的数量
    static int gap = count / THREAD_COUNT;
    // 为等待线程执行全部执行完成而使用的门闩锁
    static CountDownLatch latch;

    // 初始化数据
    @BeforeClass
    public static void beforeClass() {
        for (int i = 0; i < count; i++) {
            keys[i] = UUID.randomUUID();
            values[i] = UUID.randomUUID();
        }
    }

    @Test
    public void testHashTable() throws InterruptedException {
        Map<UUID, UUID> param = new Hashtable<UUID, UUID>();
        // 开始写操作
        Thread[] threads = new Thread[THREAD_COUNT];

        latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new WriteThread(param, i * gap, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        long middle = System.currentTimeMillis();
        // 开始读操作
        latch = new CountDownLatch(THREAD_COUNT);
        threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < threads.length; i ++) {
            threads[i] = new ReadThread(param, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("write cost:" + (middle - start) + ", read cost: " + (end - middle) + ", size: " + param.size() + "  ->Hashtable");
    }

    /**
     * 多线程死锁问题
     * @throws InterruptedException
     */
    @Test
    public void testHashMap() throws InterruptedException {
        Map<UUID, UUID> param = new HashMap<>();
        // 开始写操作
        Thread[] threads = new Thread[THREAD_COUNT];

        latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new WriteThread(param, i * gap, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        // 开始读操作
        long middle = System.currentTimeMillis();
        latch = new CountDownLatch(THREAD_COUNT);
        for (int i = 0; i < threads.length; i ++) {
            threads[i] = new ReadThread(param, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("write cost:" + (middle - start) + ", read cost: " + (end - middle) + ", size: " + param.size() + "  ->HashMap");
    }

    @Test
    public void testSynchronizedMap() throws InterruptedException {
        Map<UUID, UUID> param = Collections.synchronizedMap(new HashMap<UUID, UUID>());
        // 开始写操作
        Thread[] threads = new Thread[THREAD_COUNT];

        latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();

        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new WriteThread(param, i * gap, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        // 开始读操作
        long middle = System.currentTimeMillis();
        latch = new CountDownLatch(THREAD_COUNT);
        threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < threads.length; i ++) {
            threads[i] = new ReadThread(param, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("write cost:" + (middle - start) + ", read cost: " + (end - middle) + ", size: " + param.size() + "  ->SynchronizedMap");
    }

    @Test
    public void testConcurrentHashMap() throws InterruptedException {
        Map<UUID, UUID> param = new ConcurrentHashMap<UUID, UUID>();
        // 开始写操作
        Thread[] threads = new Thread[THREAD_COUNT];

        latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new WriteThread(param, i * gap, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        // 开始读操作
        long middle = System.currentTimeMillis();
        latch = new CountDownLatch(THREAD_COUNT);
        threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < threads.length; i ++) {
            threads[i] = new ReadThread(param, latch);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("write cost:" + (middle - start) + ", read cost: " + (end - middle) + ", size: " + param.size() + "  ->ConcurrentHashMap");
    }

    static class WriteThread extends Thread {
        Map<UUID, UUID> m;
        CountDownLatch latch;
        int start;

        public WriteThread(Map<UUID, UUID> m, int start, CountDownLatch latch) {
            this.m = m;
            this.start = start;
            this.latch = latch;
        }

        @Override
        public void run() {
            for(int i = start; i < gap + start; i++) {
                m.put(keys[i], values[i]);
            }
            latch.countDown();
        }
    }

    static class ReadThread extends Thread {
        Map<UUID, UUID> m;
        CountDownLatch latch;

        public ReadThread(Map<UUID, UUID> m, CountDownLatch latch) {
            this.m = m;
            this.latch = latch;
        }

        @Override
        public void run() {
            for (int j = 0; j < count; j++) {
                m.get(keys[j]);
            }
            latch.countDown();
        }
    }

}

执行结果

分别统计一下情况：

  1. 线程数为1，写入总数为1000000
  2. 线程数为10，写入总数为1000000
  3. 线程数为100，写入总数为1000000
    在这里插入图片描述
    从结果可以看出：
  • 当线程数为1时，不存在并发的情况，四种写入的时间差距不大，使用synchronzied的HashTable，略快于ConcurrentHashMap
  • 当线程数增多时，达到10或100时，四种的写入时间差距不多，但是对于ConcurrentHashMap的读取时间，大大优于其他两种.
  • 对于HashMap，在多线程并发写的情况下，容易造成死锁的情况。

结论

验证结果如下：

  1. 在单线程环境中，或无并发的情况下，使用HashMap的效率优于其他三种
  2. 在多线程的环境中，不能使用HashMap，容易造成死锁的现象
  3. 在多线程的环境中，若读取多的情况下，建议使用ConcurrentHashMap
爱上编程的小白
关注
专栏目录
简单测试ConcurrentHashMap Hashtable HashMap性能以及可靠性--通过现象看本质
weixin_42512490的博客
10-01 349
ConcurrentHashMap ：JDK1.8版本引入， 通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。) Hashtable ：JDK1.8以前解决线程安全问题，但效率不如ConcurrentHashMap HashMap ：线程不安...
ConcurrentHashMap性能测试
mydreamongo的专栏
05-13 2848
1、先测了一下多线程条件下hashmap，结果果然是不行啊，cpu在100%左右浮动，永远也执行不完put和get操作。 2、在能大概估计hashmap所要容纳的键值数量的情况下，可以直接用构造函数生成一定大小的map，这样避免在扩容的过程中不断的rehash成本。 3、具体代码见最后：i表示提交的线程数量，m表示每个线程执行的put和get次数。 1）如果只用单线程运行，线程内容修改如下：
ConcurrentHashMap、synchronized与线程安全
热门推荐
我想跟代码谈谈
01-04 2万+
最近做的项目中遇到一个问题：明明用了ConcurrentHashMap，可是始终线程不安全 除去项目中的业务逻辑，简化后的代码如下： public class Test40 { public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i
HashTable详解
最新发布
RRLOVEXX20210818的博客
06-22 1967
HashTable的线程安全，ConcurrentHashMap，LinkedHashMap
测试一下ConcurrentHashMap的性能
Less Is More
08-17 879
ConcurrentHashMap是线程安全的，HashTable也是线程安全，HashMap是非线程安全的，不过可以通过Collections封装成线程安全的，下面做个试验来验证下，三个集合在开启四个线程，每个线程对其进行50w次的操作，比较下会消耗多少时间。 @Test public void givenMaps_whenGetPut500KTimes_thenConcurrentMapFaster() throws Exception { Map<.
HashTable、HashMap、ConcurrentHashMap的区别
JYX2333的博客
06-22 382
HashTable1.8、HashMap1.8、ConcurrentHashMap1.8的区别 HashTable1.8 底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做相关优化； Hashtable是一种能提供快速插入和查询的数据结构，无论其包含多少Item（条目），执行查询和插入操作的平均时间复杂度总是接近O(1)； 初始size为11，扩容：newsize = olesiz
HashMap、HashTable和ConcurrentHashMap的区别
weixin_41741306的博客
08-27 505
HashMap、HashTable 简单点来说，HashTable是线程安全的HashMap，都实现了Map接口，Map接口对键值对进行映射。但还是有些不同，这里从三点来说：线程安全性，同步(synchronization)，以及速度。 我们先来看看HashMap的底层: public class HashMap<K,V> extends AbstractMap&...
Hashtable，HashMap，ConcurrentHashMap的原理和区别
ying_coder的博客
03-26 591
(1)HashMap不是线程安全的，不支持并发操作，没有同步方法。ConcurrentHashMap是线程安全的，支持并发操作，通过继承 ReentrantLock（JDK1.7的重入锁）/CAS和synchronized(JDK1.8的内置锁)来进行加锁（分段锁），每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 segment 是线程安全的，也就实现了全局的线程安全。 (2)J...
HashTable, HashMap, ConcurrentHashMap
09-05
HashTable、HashMap 和 ConcurrentHashMap 都是 Java 中用于存储键值对的数据结构，它们的主要区别在于线程安全性和性能。 1. HashTable：在早期的 Java 版本中引入，是一个线程安全的哈希表实现。它使用 ...
HashMap和ConcurrentHashMap区别看完没人能难住你
weixin_44741610的博客
09-05 6282
关于HashMap与ConcurrentHashMap的的区别，在面试的时候基本都会被问到，所以下面我们就来谈谈相关知识点： 一、HashMap概述 本质浅谈 HashMap是基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap类与Hashtable大致相同。）Hashmap本质是数组加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下
Hashtable测试
m0_52936310的博客
01-31 109
Hashtable测试 package src.main.java.com.qqjx.thread; /* * @Auther wangpeng * @Date 2021/1/31 */ public class Constants { public static final int COUNT = 1000000; public static final int THRE...
Hashtable的测试
weixin_30653023的博客
06-29 78
Hashtable的测试 1 import java.util.Enumeration; 2 import java.util.Hashtable; 3 4 class TT { 5 private String name = nul...
HashMap/ConcurrentHashMap在单线程模式下的性能比较
hl_java的专栏
08-20 6598
起源 阅读源码发现jdk8中ConcurrentHashMap是基于synchronized来加锁实现多线程安全的，但是实现方式上与早期的HashTable又有了很大的区别，虽然都是使用synchronized来加锁，但是锁的粒度不一样，大致可以作如下理解： HashTable JDK1.0版本开始提供，为了保证线程安全，内部使用了1把锁，读读、读写操作均会锁竞争 HashTable这种键值...
HashMap和ConcurrentMap性能测试
zhangshengqiang168的博客
08-12 2328
测试代码: public static void main(String[] args) { Map map=new HashMap(); User user=new User(1L,"san",2,"wuhan ","2",true); ConcurrentMap map1=new ConcurrentHashMap(); in...
(转)C# Hashtable Synchronized vs SyncRoot
weixin_30583563的博客
05-26 277
摘自：http://www.afugame.com/club/dispbbs.asp?boardid=13&id=5236& page=1&move=nextSynchronized vs SyncRoot 我们知道，在.net的一些集合类型中，譬如Hashtable和ArrayList，都有Synchronized静态方法和SyncRoot实例方法，他们之间有联系吗？我怎...
HashTable的实现测试
bertzhang的专栏
02-24 831
1）冲突解决方式，通过链表解决 2）slot数组中是否保存数据的问题，这个是一个容易让人困惑的问题，解决方案是slot不是HashNode的数组，而是一组指向HashNode的指针，因此slot数组中肯定不会保存数据 3）slot大小的选择，在HashTable的构造函数中设定大小，但hash函数使用了乘法策略，因此需要找到一个2^p>用户给的size的p，以2^p作为size，但存在这样的情
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值