Fixed - RLocalCachedMap.delete() method clears local cache asynchronously. #3966

redisson/src/main/java/org/redisson/RedissonLocalCachedMap.java

@@ -598,7 +598,7 @@ public class RedissonLocalCachedMap<K, V> extends RedissonMap<K, V> implements R
     @Override
     public RFuture<Boolean> deleteAsync() {
         cache.clear();
-        ByteBuf msgEncoded = encode(new LocalCachedMapClear(listener.generateId(), false));
+        ByteBuf msgEncoded = encode(new LocalCachedMapClear(instanceId, listener.generateId(), false));
         return commandExecutor.evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                 "if redis.call('del', KEYS[1], KEYS[3]) > 0 and ARGV[2] ~= '0' then "
                 + "redis.call('publish', KEYS[2], ARGV[1]); "

redisson/src/main/java/org/redisson/cache/LocalCacheListener.java

@@ -188,6 +188,7 @@ public abstract class LocalCacheListener {
                     
                     if (msg instanceof LocalCachedMapClear) {
                         LocalCachedMapClear clearMsg = (LocalCachedMapClear) msg;
+                        if (!Arrays.equals(clearMsg.getExcludedId(), instanceId)) {
                             cache.clear();
 
                             if (clearMsg.isReleaseSemaphore()) {
@@ -195,6 +196,7 @@ public abstract class LocalCacheListener {
                                 semaphore.releaseAsync();
                             }
                         }
+                    }
                     
                     if (msg instanceof LocalCachedMapInvalidate) {
                         LocalCachedMapInvalidate invalidateMsg = (LocalCachedMapInvalidate) msg;
@@ -249,8 +251,9 @@ public abstract class LocalCacheListener {
     
     public RFuture<Void> clearLocalCacheAsync() {
         RPromise<Void> result = new RedissonPromise<Void>();
+        cache.clear();
         byte[] id = generateId();
-        RFuture<Long> future = invalidationTopic.publishAsync(new LocalCachedMapClear(id, true));
+        RFuture<Long> future = invalidationTopic.publishAsync(new LocalCachedMapClear(instanceId, id, true));
         future.onComplete((res, e) -> {
             if (e != null) {
                 result.tryFailure(e);
@@ -258,7 +261,7 @@ public abstract class LocalCacheListener {
             }
 
             RSemaphore semaphore = getClearSemaphore(id);
-            semaphore.tryAcquireAsync(res.intValue(), 50, TimeUnit.SECONDS).onComplete((r, ex) -> {
+            semaphore.tryAcquireAsync(res.intValue() - 1, 50, TimeUnit.SECONDS).onComplete((r, ex) -> {
                 if (ex != null) {
                     result.tryFailure(ex);
                     return;

redisson/src/main/java/org/redisson/cache/LocalCachedMapClear.java

@@ -25,17 +25,23 @@ import java.io.Serializable;
 @SuppressWarnings("serial")
 public class LocalCachedMapClear implements Serializable {
 
+    private byte[] excludedId;
     private byte[] requestId;
     private boolean releaseSemaphore;
 
     public LocalCachedMapClear() {
     }
     
-    public LocalCachedMapClear(byte[] requestId, boolean releaseSemaphore) {
+    public LocalCachedMapClear(byte[] excludedId, byte[] requestId, boolean releaseSemaphore) {
+        this.excludedId = excludedId;
         this.requestId = requestId;
         this.releaseSemaphore = releaseSemaphore;
     }
 
+    public byte[] getExcludedId() {
+        return excludedId;
+    }
+
     public boolean isReleaseSemaphore() {
         return releaseSemaphore;
     }

redisson/src/main/java/org/redisson/cache/LocalCachedMessageCodec.java

@@ -36,15 +36,15 @@ public class LocalCachedMessageCodec extends BaseCodec {
 
     public static final LocalCachedMessageCodec INSTANCE = new LocalCachedMessageCodec();
     
-    private final Decoder<Object> decoder = new Decoder<Object>() {
-        @Override
-        public Object decode(ByteBuf buf, State state) throws IOException {
+    private final Decoder<Object> decoder = (buf, state) -> {
         byte type = buf.readByte();
         if (type == 0x0) {
+            byte[] excludedId = new byte[16];
+            buf.readBytes(excludedId);
             byte[] id = new byte[16];
             buf.readBytes(id);
             boolean releaseSemaphore = buf.readBoolean();
-                return new LocalCachedMapClear(id, releaseSemaphore);
+            return new LocalCachedMapClear(excludedId, id, releaseSemaphore);
         }
 
         if (type == 0x1) {
@@ -112,17 +112,14 @@ public class LocalCachedMessageCodec extends BaseCodec {
         }
 
         throw new IllegalArgumentException("Can't parse packet");
-        }
     };
     
-    private final Encoder encoder = new Encoder() {
-
-        @Override
-        public ByteBuf encode(Object in) throws IOException {
+    private final Encoder encoder = in -> {
         if (in instanceof LocalCachedMapClear) {
             LocalCachedMapClear li = (LocalCachedMapClear) in;
             ByteBuf result = ByteBufAllocator.DEFAULT.buffer(1);
             result.writeByte(0x0);
+            result.writeBytes(li.getExcludedId());
             result.writeBytes(li.getRequestId());
             result.writeBoolean(li.isReleaseSemaphore());
             return result;
@@ -191,7 +188,6 @@ public class LocalCachedMessageCodec extends BaseCodec {
         }
 
         throw new IllegalArgumentException("Can't encode packet " + in);
-        }
     };
 
 

redisson/src/test/java/org/redisson/RedissonLocalCachedMapTest.java

@@ -108,6 +108,21 @@ public class RedissonLocalCachedMapTest extends BaseMapTest {
         assertThat(cachedMap.containsKey("a")).isFalse();
     }
 
+    @Test
+    public void testPutAfterDelete() {
+        RMap<String, String> map = redisson.getLocalCachedMap("test", LocalCachedMapOptions.defaults());
+
+        for (int i = 0; i < 1_000; i++) {
+            map.delete();
+
+            map.put("key", "val1");
+            map.get("key");
+            map.put("key", "val2");
+            String val = map.get("key");
+            assertThat(val).isEqualTo("val2");
+        }
+    }
+
     @Test
     public void testMapLoaderGet() {
         Map<String, String> cache = new HashMap<>();