并发(十五)：怎么证明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确实存在内存可见性的问题。

上述的证明过程应该还有更优化的办法，请大家指点。