cacheMap property optimization

[XiaoWeiKIN]

I wonder why cacheMap properties use the AtomicReference wrapper in ClientWorker, but cacheMap writes with lock. What's the point of using AtomicReference? I think ConcurrentHashMap could be used to replace it with a lock-free operation to improve concurrency.

[paderlol]

Because this is not an operation, concurrenthashmap can only guarantee its own operation, and there is a reference replacement operation here

[XiaoWeiKIN]

Because this is not an operation, concurrenthashmap can only guarantee its own operation, and there is a reference replacement operation here

What should replace the reference?

[XiaoWeiKIN]

Because this is not an operation, concurrenthashmap can only guarantee its own operation, and there is a reference replacement operation here

What's the meaning of using a set method to replace a reference after synchronized so why not use CAS?

[paderlol]

Maybe what I said is not clear enough. In many cases, not only do operations on the cachemap, it is a complete operation unit, and then why not use concurrent operations, because essentially the contents of the concurrenthashmap are also synchronized for locking

[XiaoWeiKIN]

Maybe what I said is not clear enough. In many cases, not only do operations on the cachemap, it is a complete operation unit, and then why not use concurrent operations, because essentially the contents of the concurrenthashmap are also synchronized for locking

I think this code can be modified in the following way：

 CacheData cache = getCache(dataId, group, tenant);
        if (null != cache) {
            return cache;
        }
        String key = GroupKey.getKeyTenant(dataId, group, tenant);
        synchronized (cacheMap) {
            CacheData cacheFromMap = getCache(dataId, group, tenant);
            // multiple listeners on the same dataid+group and race condition,so
            // double check again
            // other listener thread beat me to set to cacheMap
            if (null != cacheFromMap) {
                cache = cacheFromMap;
                // reset so that server not hang this check
                cache.setInitializing(true);
            } else {
                cache = new CacheData(configFilterChainManager, agent.getName(), dataId, group, tenant);
                // fix issue # 1317
                if (enableRemoteSyncConfig) {
                    String[] ct = getServerConfig(dataId, group, tenant, 3000L);
                    cache.setContent(ct[0]);
                }
            }

            Map<String, CacheData> copy = new HashMap<String, CacheData>(this.cacheMap.get());
            copy.put(key, cache);
            cacheMap.set(copy);
        }

like:

  cacheData = map.computeIfAbsent(GroupKey.getKeyTenant(dataId, group, tenant),key->{
            cache = new CacheData(configFilterChainManager, agent.getName(), dataId, group, tenant);
            // fix issue # 1317
            if (enableRemoteSyncConfig) {
                String[] ct = getServerConfig(dataId, group, tenant, 3000L);
                cache.setContent(ct[0]);
            }
            return cache;
        });

        cache.setInitializing(true);

computeIfAbsent guarantees atomic units.

[paderlol]

Your writing code looks good, but unfortunately now the client only supports the 1.6 jdk version

[XiaoWeiKIN]

Your writing code looks good, but unfortunately now the client only supports the 1.6 jdk versio
That's really a shame

[paderlol]

But in version 2.0 we will upgrade to version 1.8 using java

[XiaoWeiKIN]

But in version 2.0 we will upgrade to version 1.8 using java
ok, it should be optimized using AtomicReference as well, so I'll give it a try

[paderlol]

Welcome to contribute your code

[XiaoWeiKIN]

In JDK1.6, putIfAbsent from ConcurrentHashMap is thread safe, using synchronized on a Node to reduce the chance of lock collisions compared to cachemap. AtomicReference on the other hand, guarantees that it will not be initialized multiple times

 private final ConcurrentHashMap<String, AtomicReference<CacheData>> cacheMap =
        new ConcurrentHashMap<String, AtomicReference<CacheData>>();

 String key = GroupKey.getKeyTenant(dataId, group, tenant);
        AtomicReference<CacheData> cacheData = new AtomicReference<CacheData>();
        // multiple listeners on the same dataid+group and race condition
        AtomicReference<CacheData> lastCacheData = cacheMap.putIfAbsent(key, cacheData);
        if (lastCacheData == null) {
            CacheData cache = new CacheData(configFilterChainManager, agent.getName(), dataId, group, tenant);
            // strengthen the check
            if (cacheData.compareAndSet(null, cache)) {
                //fix issue # 1317
                if (enableRemoteSyncConfig) {
                    String[] ct = getServerConfig(dataId, group, tenant, 3000L);
                    cache.setContent(ct[0]);
                }
                lastCacheData = cacheData;
            }
            return lastCacheData.get();
        }

[paderlol]

It's looks good，u can try it and test it performance in Nacos