Java ConcurrentHashMap在多线程应用程序中未提供正确的输出

我创建了一个示例来理解并发HashMap，但它似乎在7-8次运行后给出了不确定的输出

在我的示例中，我创建了三个线程（它们模仿三个服务来获取数学、科学、英语的分数），它们更新了一个concurent HashMap，该HashMap只有3个键值对（键值是三个名称a、B、C，运行结束时的值应该是三个主题的累积分数）

我正在张贴下面的代码，请告知

下面显示了错误的输出（正确的输出应该以全部完成main:{C=27，A=57，B=42}结尾）

ConcurrentHashMapExample类：

    package com.ll.thread.concurrency;

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

    public class ConcurrentHashMapExample {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ConcurrentHashMap<String, Integer>   concurrentHashMap = new ConcurrentHashMap<String, Integer>();
            concurrentHashMap.put("A", 0);
            concurrentHashMap.put("B", 0);
            concurrentHashMap.put("C", 0);
            CountDownLatch  countDownLatch = new CountDownLatch(3);

            Runnable runnableScience = new Worker(concurrentHashMap , "Science" , countDownLatch);
            Runnable runnableMath = new Worker(concurrentHashMap , "Math" , countDownLatch);
            Runnable runnableEnglish = new Worker(concurrentHashMap , "English" , countDownLatch);

            new Thread(runnableScience , "Science").start();
            new Thread(runnableMath ,"Math").start();
            new Thread(runnableEnglish ,"English").start();

            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("All Done " + Thread.currentThread().getName() + " : "+concurrentHashMap);




            concurrentHashMap = null;



        }

    }

package com.ll.thread.concurrency；
导入java.util.Iterator；
导入java.util.concurrent.ConcurrentHashMap；
导入java.util.concurrent.CountDownLatch；
公共类ConcurrentHashMapExample{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
ConcurrentHashMap ConcurrentHashMap=新的ConcurrentHashMap（）；
concurrentHashMap.put（“A”，0）；
concurrentHashMap.put（“B”，0）；
concurrentHashMap.put（“C”，0）；
CountDownLatch CountDownLatch=新的CountDownLatch（3）；
Runnable runnableScience=新工人（concurrentHashMap，“科学”，倒计时锁存）；
Runnable runnableMath=新工作者（concurrentHashMap，“数学”，countDownLatch）；
Runnable runnableEnglish=新工人（concurrentHashMap，“英语”，倒计时）；
新线程（runnableScience，“Science”）.start（）；
新线程（runnableMath，“Math”）.start（）；
新线程（runnableEnglish，“English”）.start（）；
试一试{
倒计时闩锁。等待（）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
System.out.println（“全部完成”+Thread.currentThread（）.getName（）+”：“+concurrentHashMap）；
concurrentHashMap=null；
}
}

工人阶级：

    package com.ll.thread.concurrency;

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

    public class Worker  implements Runnable{

        ConcurrentHashMap<String, Integer>  concurrentHashMap ;
        String threadName = "";
        CountDownLatch  countDownLatch ;

        public Worker(ConcurrentHashMap<String, Integer> concurrentHashMap,
                String subject, CountDownLatch countDownLatch) {
            this.concurrentHashMap = concurrentHashMap;
            this.threadName = subject ;
            this.countDownLatch = countDownLatch;

            // TODO Auto-generated constructor stub
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("Within run " +Thread.currentThread().getName() + " : "+concurrentHashMap);
            try{
         for(Iterator<String>  iterator = concurrentHashMap.keySet().iterator() ;   iterator.hasNext();){
            String key = iterator.next();

            //synchronized (this) {


            if("Math".equals(Thread.currentThread().getName())) {
            if("A".equals(key))
                concurrentHashMap.put(key, concurrentHashMap.get(key) +20);
            else if("B".equals(key))
                concurrentHashMap.put(key, concurrentHashMap.get(key) + 15);
            else if("C".equals(key))
                concurrentHashMap.put(key, concurrentHashMap.get(key) +10);
            }else

            if("Science".equals(Thread.currentThread().getName())) {
                if("A".equals(key))
                    concurrentHashMap.put(key, concurrentHashMap.get(key) +19);
                else if("B".equals(key))
                    concurrentHashMap.put(key, concurrentHashMap.get(key) +14);
                else if("C".equals(key))
                    concurrentHashMap.put(key, concurrentHashMap.get(key) +9);
                }
            else
                if("English".equals(Thread.currentThread().getName())) {
                    if("A".equals(key))
                        concurrentHashMap.put(key, concurrentHashMap.get(key) +18);
                    else if("B".equals(key))
                        concurrentHashMap.put(key, concurrentHashMap.get(key) +13);
                    else if("C".equals(key))
                        concurrentHashMap.put(key, concurrentHashMap.get(key) +8);
                    }

            }
        // }
            }
            finally{

                System.out.println("Completed " + Thread.currentThread().getName() + " : " + concurrentHashMap);
                countDownLatch.countDown();
            }
         }
        }

package com.ll.thread.concurrency；
导入java.util.Iterator；
导入java.util.concurrent.ConcurrentHashMap；
导入java.util.concurrent.CountDownLatch；
公共类Worker实现了Runnable{
ConcurrentHashMap ConcurrentHashMap；
字符串threadName=“”；
倒计时闩锁倒计时闩锁；
公共工作者（ConcurrentHashMap ConcurrentHashMap，
字符串主题，CountDownLatch（CountDownLatch）{
this.concurrentHashMap=concurrentHashMap；
this.threadName=主题；
this.countDownLatch=countDownLatch；
//TODO自动生成的构造函数存根
}
@凌驾
公开募捐{
//TODO自动生成的方法存根
System.out.println（“运行内”+Thread.currentThread（）.getName（）+”：“+concurrentHashMap）；
试一试{
for（Iterator Iterator=concurrentHashMap.keySet（）.Iterator（）；Iterator.hasNext（）；）{
String key=iterator.next（）；
//已同步（此）{
if（“Math”.equals（Thread.currentThread（）.getName（）））{
如果（“A”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+20）；
否则，如果（“B”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+15）；
否则，如果（“C”等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+10）；
}否则
if（“Science”.equals（Thread.currentThread（）.getName（）））{
如果（“A”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+19）；
否则，如果（“B”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+14）；
否则，如果（“C”等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+9）；
}
其他的
if（“English”.equals（Thread.currentThread（）.getName（）））{
如果（“A”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+18）；
否则，如果（“B”。等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+13）；
否则，如果（“C”等于（键））
concurrentHashMap.put（key，concurrentHashMap.get（key）+8）；
}
}
// }
}
最后{
System.out.println（“已完成”+Thread.currentThread（）.getName（）+”：“+concurrentHashMap）；
countdownlock.countDown（）；
}
}
}

我认为您在测试中不需要

ConcurrentHashMap

。在执行线程之前初始化映射。相反，您可以使用由

String

键和

AtomicInteger

值参数化的常规

HashMap

：

HashMap<String, AtomicInteger> concurrentHashMap = ...
concurrentHashMap.put("A", new AtomicInteger(0));
...

---

你期待什么？

ConcurrentHashMap

（在

ConcurrentHashMap

中）意味着，为了保护其内部结构，map尽可能地负责同步。这并不意味着使用它会自动修复使用map的代码中的竞争条件。

concurrentHashMap.put（key，concurrentHashMap.get（key）+19）不是原子的：映射可能会在get和put之间更新…从显示的代码来看，您没有正确使用它！我建议您首先阅读接口ConcurrentMap的javadocs（ConcurrentHashMap是一个实现），特别是理解为什么需要新方法Hanks..查看了文档..似乎我的用例不适合测试ConcurrentHashMap。
HashMap<String, AtomicInteger> concurrentHashMap = ...
concurrentHashMap.put("A", new AtomicInteger(0));
...

concurrentHashMap.get(key).addAndGet(20);