线程安全计数问题，为什么代码中的计数有问题？

Question

为什么以下代码线程不安全？

在ConcurrentHashMap中，key为当前时间，value为MutableInteger，mutableInteger用于计数，set方法和get方法已经锁定。 为什么最终值不正确？

public class MutableInteger {
    private volatile int value;

    public MutableInteger() {
    }

    public synchronized int getValue() {
        return value;
    }

    public synchronized void setValue(int value) {
        this.value = value;
    }
}

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.*;

public class LinkedQueue {

    static ConcurrentHashMap<String,MutableInteger> map = new ConcurrentHashMap();

    public static class CountQueue{
        static BlockingQueue<Calendar> queue = new LinkedBlockingQueue<Calendar>();

        public void produce() throws InterruptedException{
            queue.put(Calendar.getInstance());
        }
        public Calendar consume() throws InterruptedException{
            return queue.take();
        }
    }

    /**
     */
    public static void recordFlow(){
        final CountQueue queue = new CountQueue();
        class Producer implements Runnable {
            public void run() {
                try {
                    queue.produce();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        class Consumer implements Runnable {
            public void run() {
                try {
                    getdata(queue.consume());
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }

        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer = new Producer();
        Consumer consumer = new Consumer();
        service.submit(producer);
        service.submit(consumer);
        service.shutdown();
    }

    /**
     *
     *
     * @param c 队列中取出的时间
     */
    public static void getdata(Calendar c){
        try{
            saveFlow(c);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    // 接口流量记录
    public static void saveFlow(Calendar c){
        System.out.println("Thread Name:"+Thread.currentThread().getName());
        SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat sdfHour = new SimpleDateFormat("yyyy-MM-dd HH");
        SimpleDateFormat sdfMinute = new SimpleDateFormat("yyyy-MM-dd HH:mm");

        String dayAcceptKey = sdfDate.format(c.getTime());
        String hourAcceptKey = sdfHour.format(c.getTime());
        String minuteAcceptKey = sdfMinute.format(c.getTime());
        
        MutableInteger newMinuteAcceptKey = new MutableInteger();
        newMinuteAcceptKey.setValue(1);
        MutableInteger oldMinuteAcceptKey = map.put(minuteAcceptKey, newMinuteAcceptKey);
        if(null != oldMinuteAcceptKey) {
            newMinuteAcceptKey.setValue(oldMinuteAcceptKey.getValue() + 1);
        }
        System.out.println("minute in map："+ minuteAcceptKey + ","+ newMinuteAcceptKey.getValue());
        MutableInteger newHourAcceptKey = new MutableInteger();
        newHourAcceptKey.setValue(1);
        MutableInteger oldHourAcceptKey = map.put(hourAcceptKey, newHourAcceptKey);
        if(null != oldHourAcceptKey) {
            newHourAcceptKey.setValue(oldHourAcceptKey.getValue() + 1);
        }
        System.out.println("hour in map：" + hourAcceptKey + "," + newHourAcceptKey.getValue());
        MutableInteger newDayAcceptKey = new MutableInteger();
        newDayAcceptKey.setValue(1);
        MutableInteger oldDayAcceptKey = map.put(dayAcceptKey, newDayAcceptKey);
        if(null != oldDayAcceptKey) {
            newDayAcceptKey.setValue(oldDayAcceptKey.getValue() + 1);
        }
        System.out.println("day in map：" + dayAcceptKey + "," + newDayAcceptKey.getValue());
    }

    public static void main(String[] args){
        for(int i=0;i<1000;i++) {
            recordFlow();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========================");
        for(String key:map.keySet()){
            System.out.println("key and value:" +key + " " + map.get(key).getValue());
        }
    }
}

MutableInteger中的get方法和set方法已经被锁定，使用的是ConcurrentHashMap，但是main方法中的结果数据不正确。 请帮我看看是什么问题，谢谢

Answer 1

您反复遇到同样的问题，即您正在以非同步方式与共享数据结构进行交互。 map是一个ConcurrentHashMap这一事实意味着单独的.get和.put调用不会破坏线程安全，您可以使用多个这样的调用，并假设 map 在它们之间不会发生变化。

    MutableInteger newMinuteAcceptKey = new MutableInteger();
    newMinuteAcceptKey.setValue(1);
    MutableInteger oldMinuteAcceptKey = map.put(minuteAcceptKey, newMinuteAcceptKey);
    // let's assume here something happens
    if(null != oldMinuteAcceptKey) {
        newMinuteAcceptKey.setValue(oldMinuteAcceptKey.getValue() + 1);
    }

如果在上面标有注释的地方，其他一些线程也将一个新的MutableInteger放入 map，那么您稍后对newMinuteAcceptKey的更改（实际上应该是newMinuteAcceptValue ，因为它不是键）将是无关紧要的。 因为该值不再在地图中。

为了解决这个问题，用一个计算或merge调用替换整个事情。 那么你也不是真的需要MutableInteger ，但可以切换到一个无聊的旧Integer ，如果你愿意：

map.merge(minuteAcceptKey, 1, Integer::sum);

这些方法将以原子方式完成整个操作，即确保在它们完成之前没有其他调用操作数据。

一个简短的总结：如果你需要一个ConcurrentHashMap ，那么你几乎不想有普通.put()调用（除了可能以单线程方式填充初始值），因为这些方法具有相当弱的并发保证（即它们只保证不破坏map，但任何其他操作都可以随时轻松覆盖它们的值）。