HashMap 是线程安全的吗,为什么不是线程安全的?

HashMap 是线程安全的吗,为什么不是线程安全的?

在并发编程中,证明一个类是线程安全的很难,所以我们经常试着去证明类是线程不安全,证明的方法一般有如下几种:

1. 对象不能安全发布,构造过程逃逸;

2. 内存的可见性,内容不能及时发布;

3. 操作不是原子的;

4. 读写不能同步;

5. 存在死锁的可能性;

我们经常说HashMap不是线程安全的,但如何证明呢?大部分网上的例子都是从源码进行分析,没有从运行结果中分析,基于这个原因,我试着构造一个测试用例,证明HashMap存在内存可见性的问题,具体思路过程如下:

1. 创建多个线程,所有的线程都共享一个HashMap,并利用HashMap中的键值来决定线程是否继续运行;

2. 在HashMap中存入一个键值,用于指示线程是否继续运行;

3. 不断更新这个键值,逐渐停止所有线程;

4. 如果存在未停止的线程,则说明HashMap不是线程安全的;

下面是具体的实现:

public class HashMapTest {

    //  使用ConcurrentHashMap可运行正常
    //final static ConcurrentHashMap<String, String> ch = new ConcurrentHashMap<>();
    final static HashMap<String, String> ch = new HashMap<>();

    //  运行的线程
    public static class R implements Runnable {

        private String end;

        public R(String end) {
            super();
            this.end = end;
        }

        @Override
        public void run() {
            while(!this.end.equals(ch.get("end"))) {
                System.out.println(this.end);
            }
            System.out.println(this.end + ": is End!");
        }

    }

    public static void main(String[] args) {
        //  启动线程
        for(int i = 0; i < 10; i++) {
            new Thread(new R(String.valueOf(i))).start();
        }
        new Thread(() -> {
            int j = 0;
            while(j < 10) {
                ch.put("end", String.valueOf(j));
                //  让其他线程有执行的机会
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                j ++;
            }
        }).start();
    }

}

运行上面的例子,大部分情况下都会出现线程无法结束的情形,但这也有一种可能是,此线程在HashMap切换值的期间根本没有得到执行的机会,所以我们还需要分析打印的结果,经过分析,发现HashMap确实存在内存可见性的问题。




阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页