ConcurrentHashMap的使用

一.ConcurrentHashMap的简要总结:

1、public V get(Object key)不涉及到锁,也就是说获得对象时没有使用锁;

2、put、remove方法要使用锁,但并不一定有锁争用,原因在于ConcurrentHashMap将缓存的变量分到多个Segment,每个Segment上有一个锁,只要多个线程访问的不是一个Segment就没有锁争用,就没有堵塞,各线程用各自的锁,ConcurrentHashMap缺省情况下生成16个Segment,也就是允许16个线程并发的更新而尽量没有锁争用;

3、Iterator对象的使用,不一定是和其它更新线程同步,获得的对象可能是更新前的对象,

ConcurrentHashMap允许一边更新、一边遍历,也就是说在Iterator对象遍历的时候,ConcurrentHashMap也可以进行remove,put操作,且遍历的数据会随着remove,put操作产出变化,

所以希望遍历到当前全部数据的话,要么以ConcurrentHashMap变量为锁进行同步(synchronized该变量),要么使用CopiedIterator包装iterator,使其拷贝当前集合的全部数据,但是这样生成的iterator不可以进行remove操作。

 
二.Hashtable和ConcurrentHashMap的不同点:

1、Hashtable对get,put,remove都使用了同步操作,它的同步级别是正对Hashtable来进行同步的,也就是说如果有线程正在遍历集合,其他的线程就暂时不能使用该集合了,这样无疑就很容易对性能和吞吐量造成影响,从而形成单点。而ConcurrentHashMap则不同,它只对put,remove操作使用了同步操作,get操作并不影响,详情请看以上第1,2点,当前ConcurrentHashMap这样的做法对一些线程要求很严格的程序来说,还是有所欠缺的,对应这样的程序来说,如果不考虑性能和吞吐量问题的话,个人觉得使用Hashtable还是比较合适的;

2、Hashtable在使用iterator遍历的时候,如果其他线程,包括本线程对Hashtable进行了put,remove等更新操作的话,就会抛出ConcurrentModificationException异常,但如果使用ConcurrentHashMap的话,就不用考虑这方面的问题了,详情请看以上第3点;

 

1.HashMap或者ArrayList边遍历边删除数据会报java.util.ConcurrentModificationException异常

    Map<Long, String> mReqPacket = new HashMap<Long, String>();
            for (long i = 0; i < 15; i++) {
                mReqPacket.put(i, i + "");
            }
     
            for (Entry<Long, String> entry : mReqPacket.entrySet()) {
                long key = entry.getKey();
                String value = entry.getValue();
                if (key < 10) {
                    mReqPacket.remove(key);
                }
            }
     
            for (Entry<Long, String> entry : mReqPacket.entrySet()) {
                Log.d(entry.getKey() + " " + entry.getValue());
            }

 




所以要用迭代器删除元素:

  

Map<Long, String> mReqPacket = new HashMap<Long, String>();
            for (long i = 0; i < 15; i++) {
                mReqPacket.put(i, i + "");
            }
     
            for (Iterator<Entry<Long, String>> iterator = mReqPacket.entrySet().iterator(); iterator.hasNext();) {
                Entry<Long, String> entry = iterator.next();
                long key = entry.getKey();
                if (key < 10) {
                    iterator.remove();
                }
            }
     
            for (Entry<Long, String> entry : mReqPacket.entrySet()) {
                Log.d(entry.getKey() + " " + entry.getValue());
            }

 




2.对ConcurrentHashMap边遍历边删除或者增加操作不会产生异常(可以不用迭代方式删除元素),因为其内部已经做了维护,遍历的时候都能获得最新的值。即便是多个线程一起删除、添加元素也没问题。

   Map<Long, String> conMap = new ConcurrentHashMap<Long, String>();
            for (long i = 0; i < 15; i++) {
                conMap.put(i, i + "");
            }
     
            for (Entry<Long, String> entry : conMap.entrySet()) {
                long key = entry.getKey();
                if (key < 10) {
                    conMap.remove(key);
                }
            }
     
            for (Entry<Long, String> entry : conMap.entrySet()) {
                Log.d(entry.getKey() + " " + entry.getValue());
            }

 



3.一个线程对ConcurrentHashMap增加数据,另外一个线程在遍历时就能获得。

     

      static Map<Long, String> conMap = new ConcurrentHashMap<Long, String>();
        public static void main(String[] args) throws InterruptedException {
            for (long i = 0; i < 5; i++) {
                conMap.put(i, i + "");
            }
     
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    conMap.put(100l, "100");
                    Log.d("ADD:" + 100);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
     
            });
            Thread thread2 = new Thread(new Runnable() {
                public void run() {
                    for (Iterator<Entry<Long, String>> iterator = conMap.entrySet().iterator(); iterator.hasNext();) {
                        Entry<Long, String> entry = iterator.next();
                        Log.d(entry.getKey() + " - " + entry.getValue());
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            thread.start();
            thread2.start();
     
            Thread.sleep(3000);
            Log.d("--------");
            for (Entry<Long, String> entry : conMap.entrySet()) {
                Log.d(entry.getKey() + " " + entry.getValue());
            }
     
        }

 



输出:

    ADD:100
    0 - 0
    100 - 100
    2 - 2
    1 - 1
    3 - 3
    4 - 4
    --------
    0 0
    100 100
    2 2
    1 1
    3 3
    4 4
---------------------
版权声明:本文为CSDN博主「Loongxu」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/heng615975867/article/details/52799213

转载于:https://www.cnblogs.com/xuxinstyle/p/11326346.html

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值