How can you ensure safe access and modification of a HashMap in a multithreaded environment?

To safely access and modify a HashMap in a multithreaded environment in Java, you can use several approaches:

1. Collections.synchronizedMap — wraps a regular HashMap in a synchronized version:

Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>());

All methods of the map are synchronized, but during iteration, you need to additionally synchronize on the map object:

synchronized(syncMap) {
    for (K key : syncMap.keySet()) {
        // work with elements
    }
}

2. ConcurrentHashMap — a specialized map implementation optimized for concurrent access without full locking:

ConcurrentHashMap<K, V> concurrentMap = new ConcurrentHashMap<>();

It provides high performance and safety for concurrent reads and writes.

3. Using external synchronization — for example, locking with synchronized or ReentrantLock around HashMap operations.

It is recommended to use ConcurrentHashMap in most cases, as it provides efficient and safe access without manual synchronization.