ConcurrentHashMap и составные операции

Нет, вы не можете использовать внешнюю синхронизацию для обеспечения атомарности составных операций над ConcurrentHashMap.

Чтобы быть точным, вы можете использовать внешнюю синхронизацию для обеспечения атомарности составных операций, но только если все операции с ConcurrentHashMap также синхронизируются через одну и ту же блокировку (хотя использование ConcurrentHashMap в этом случае не имеет смысла — вы можете заменить его на обычный HashMap).

Подход с внешней синхронизацией работает с Hashtable и Collections.synchronizedMap() только потому, что они гарантируют, что их примитивные операции будут synchronized и над этими объектами. Поскольку ConcurrentHashMap не дает такой гарантии, примитивные операции могут мешать выполнению ваших составных операций, нарушая их атомарность.

Однако ConcurrentHashMap предоставляет ряд методов, которые можно использовать для реализации составных операций оптимистичным образом:

• putIfAbsent(key, value)
• remove(key, value)
• replace(key, value)
• replace(key, oldValue, newValue)

Вы можете использовать эти операции для реализации определенных составных операций без явной синхронизации, точно так же, как для AtomicReference и т. д.

Нет никаких причин, почему вы не можете. Традиционная синхронизация работает со всем, особых исключений для них нет. ConcurrentHashMaps просто использует более оптимизированные механизмы потокобезопасности, если вы хотите сделать что-то более сложное, возврат к традиционной синхронизации может быть вашим единственным вариантом (это и использование блокировок).

Вы всегда можете использовать блок synchronized. Причудливые коллекции в java.util.concurrent не запрещают этого, они просто делают его избыточным для наиболее распространенных случаев использования. Если вы выполняете составную операцию (например, вы хотите вставить два ключа, которые всегда должны иметь одинаковое значение), вы не только можете использовать внешнюю синхронизацию, но и должны.

E.g.:

String key1 = getKeyFromSomewhere();
String key2 = getKeyFromSomewhereElse();
String value = getValue();

// We want to put two pairs in the map - [key1, value] and [key2, value]
// and be sure that in any point in time both key1 and key2 have the same 
// value
synchronized(concurrenthashmap_obj) {
    concurrenthashmap_obj.put(key1, value);

    // without external syncronoziation, key1's value may have already been
    // overwritten from a different thread!
    concurrenthashmap_obj.put(key2, value);
}

Поскольку ConcurrentHashMap реализует интерфейс карты, он поддерживает все функции, которые есть у каждой базовой карты. Так что да: вы можете использовать ее как любую другую карту и игнорировать все дополнительные функции. Но тогда у вас будет более медленный HashMap.

Основное различие между синхронизированной картой и параллельной картой, как следует из названия, заключается в параллелизме. Представьте, что у вас есть 100 потоков, желающих читать с карты, если вы synchronize заблокируете 99 потоков, а 1 сможет выполнить работу. Если вы используете параллелизм, 100 потоков могут работать одновременно.

Теперь, если вы подумаете о реальной причине использования потоков, вы вскоре придете к выводу, что вам следует избавиться от всех возможных блоков synchronized, какие только можно.

Все зависит от того, что вы подразумеваете под «другой сложной операцией» и под «работой». Синхронизация работает с ConcurrentHashMap точно так же, как и с любым другим объектом.

Таким образом, если вы хотите, чтобы какое-то сложное изменение общего состояния рассматривалось как атомарное изменение, то все обращения к этому общему состоянию должны быть синхронизированы с одной и той же блокировкой. Этот замок может быть самой картой или другим объектом.

О java.util.concurrent.ConcurrentHashMap

• «полностью совместим с Hashtable в программах, которые полагаются на его потокобезопасность, но не на детали синхронизации: они не вызывают исключение ConcurrentModificationException».

• "разрешает параллелизм между операциями update"

О java-памяти

Вообще говоря, чтение безопасно с точки зрения синхронизации, но не с точки зрения памяти.

См. также "https://www.ibm.com/developerworks/java/library/j-jtp03304/".

Таким образом, synchronizaton и volatile следует использовать для управления параллельным чтением (по сравнению с записью).

О putIfAbsent

putIfAbsent – это ваш друг:

Если указанный ключ еще не связан со значением, свяжите его с данным

value. This is equivalent to
   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);

за исключением того, что действие выполняется !!!атомарно!!!.