I am currently developing a backend feature where multiple worker threads need to track and update the access frequency of shared resources in memory.

Initially, I used a standard `HashMap`, but I quickly ran into concurrent modification issues and incorrect data due to the lack of thread safety during simultaneous reads and writes. To fix this, I wrapped it using `Collections.synchronizedMap`, but now I am experiencing a noticeable performance bottleneck as the thread count scales up.

Here is a simplified version of my current thread-safe implementation:

public class ResourceTracker {

    private final Map\ accessMap = Collections.synchronizedMap(new HashMap\<\>());



    public void registerAccess(String resourceId) {

        Integer currentCount = accessMap.get(resourceId);

        if (currentCount == null) {

            accessMap.put(resourceId, 1);

        } else {

            accessMap.put(resourceId, currentCount + 1);

        }

    }

}

I understand that `ConcurrentHashMap` uses bucket-level locking and could improve throughput, but I am confused about how to perform the "read-modify-write" operation atomically without introducing race conditions between the `get` and `put` calls.

What is the best way to refactor the `registerAccess` method using `ConcurrentHashMap` or `AtomicInteger` to ensure the increment operation is completely atomic and highly performant under heavy concurrent load?

Thanks in advance!