在ConcurrentHashMap线程安全中并发更新BigDecimal

Question

Is the code below thread/concurrency safe when there are multiple threads calling the totalBadRecords() method from inside other method? Both map objects parameters to this method are ConcurrentHashMap . I want to ensure that each call updates the total properly.

If it is not safe, please explain what do I have to do to ensure thread safety.

Do I need to synchronize the add/put or is there a better way?

Do i need to synchronize the get method in TestVO. TestVO is simple java bean and having getter/setter method.

Below is my Sample code:

public void totalBadRecords(final Map<Integer, TestVO> sourceMap,
            final Map<String, String> logMap) {


        BigDecimal badCharges  = new BigDecimal(0);
        boolean badRecordsFound = false;

        for (Entry<Integer, TestVO> e : sourceMap.entrySet()) {
            if ("Y".equals(e.getValue().getInd()))
                badCharges = badCharges.add(e.getValue()
                        .getAmount());
            badRecordsFound = true;
        }

        if (badRecordsFound)
            logMap.put("badRecordsFound:", badCharges.toPlainString());

    }

Answer 1

That depends on how your objects are used in your whole application.

If each call to totalBadRecords takes a different sourceMap and the map (and its content) is not mutated while counting, it's thread-safe:

• badCharges is a local variable, it can't be shared between thread, and is thus thread-safe (no need to synchronize add )
• logMap can be shared between calls to totalBadRecords : the method put of ConcurrentHashMap is already synchronized (or behaves as if it was).
• if instances of TestVO are not mutated, the value from getValue() and getInd() are always coherent with one other.
• the sourceMap is not mutated, so you can iterate over it.

Actually, in this case, you don't need a concurrent map for sourceMap . You could even make it immutable.

If the instances of TestVO and the sourceMap can change while counting, then of course you could be counting wrongly.

Answer 2

It depends on what you mean by thread-safe. And that boils down to what the requirements for this method are.

At the data structure level, the method will not corrupt any data structures, because the only data structures that could be shared with other threads are ConcurrentHashMap instances, and they safe against that kind of problem.

The potential thread-safety issue is that iterating a ConcurrentHashMap is not an atomic operation. The guarantees for the iterators are such that you are not guaranteed to see all entries in the iteration if the map is updated (eg by another thread) while you are iterating. That means that the totalBadRecords method may not give an accurate count if some other thread modifies the map during the call. Whether this is a real thread-safety issue depends on whether or not the totalBadRecords is required to give an accurate result in that circumstance.

---

If you need to get an accurate count, then you have to (somehow) lock out updates to the sourceMap while making the totalBadRecords call. AFAIK, there is no way to do this using (just) the ConcurrentHashMap API, and I can't think of a way to do it that doesn't make the map a concurrency bottleneck.

In fact, if you need to calculate accurate counts, you have to use external locking for (at least) the counting operation, and all operations that could change the outcome of the counting. And even that doesn't deal with the possibility that some thread may modify one of the TestVO objects while you are counting records, and cause the TestVO to change from "good" to "bad" or vice-versa.

Answer 3

You could use something like the following.

That would guarantee you that after a call to the totalBadRecords method, the String representing the bad charges in the logMap is accurate, you don't have lost updates . Of course a phantom read can always happen, as you do not lock the sourceMap.

private static final String BAD_RECORDS_KEY = "badRecordsFound:";

    public void totalBadRecords(final ConcurrentMap<Integer, TestVO> sourceMap,
            final ConcurrentMap<String, String> logMap) {

        while (true) {
            // get the old value that is going to be replaced.
            String oldValue = logMap.get(BAD_RECORDS_KEY);

            // calculate new value
            BigDecimal badCharges = BigDecimal.ZERO;
            for (TestVO e : sourceMap.values()) {
                if ("Y".equals(e.getInd()))
                    badCharges = badCharges.add(e.getAmount());
            }
            final String newValue = badCharges.toPlainString();

            // insert into map if there was no mapping before
            if (oldValue == null) {
                oldValue = logMap.putIfAbsent(BAD_RECORDS_KEY, newValue);
                if (oldValue == null) {
                    oldValue = newValue;
                }
            }

            // replace the entry in the map
            if (logMap.replace(BAD_RECORDS_KEY, oldValue, newValue)) {
                // update succeeded -> there where no updates to the logMap while calculating the bad charges.
                break;
            }
        }
    }