Improves the performance of obtaining write connections.

Signed-off-by: c00887447 <[email protected]>

Author: c00887447

src/main/java/io/lettuce/core/cluster/PooledClusterConnectionProvider.java

@@ -157,47 +157,44 @@ public CompletableFuture<StatefulRedisConnection<K, V>> getConnectionAsync(Conne
     }
 
     private CompletableFuture<StatefulRedisConnection<K, V>> getWriteConnection(int slot) {
+        if (writers[slot] == null) {
+            stateLock.lock();
+            try {
+                if (writers[slot] == null) {
+                    RedisClusterNode master = partitions.getMasterBySlot(slot);
+                    if (master == null) {
+                        clusterEventListener.onUncoveredSlot(slot);
+                        return Futures.failed(new PartitionSelectorException(
+                                "Cannot determine a partition for slot " + slot + ".", partitions.clone()));
+                    }
 
-        CompletableFuture<StatefulRedisConnection<K, V>> writer;// avoid races when reconfiguring partitions.
+                    // Use always host and port for slot-oriented operations. We don't want to get reconnected on a different
+                    // host because the nodeId can be handled by a different host.
+                    RedisURI uri = master.getUri();
+                    ConnectionKey key = new ConnectionKey(ConnectionIntent.WRITE, uri.getHost(), uri.getPort());
 
-        stateLock.lock();
-        try {
-            writer = writers[slot];
-        } finally {
-            stateLock.unlock();
-        }
+                    ConnectionFuture<StatefulRedisConnection<K, V>> future = getConnectionAsync(key);
 
-        if (writer == null) {
-            RedisClusterNode master = partitions.getMasterBySlot(slot);
-            if (master == null) {
-                clusterEventListener.onUncoveredSlot(slot);
-                return Futures.failed(new PartitionSelectorException("Cannot determine a partition for slot " + slot + ".",
-                        partitions.clone()));
-            }
+                    return future.thenApply(connection -> {
 
-            // Use always host and port for slot-oriented operations. We don't want to get reconnected on a different
-            // host because the nodeId can be handled by a different host.
-            RedisURI uri = master.getUri();
-            ConnectionKey key = new ConnectionKey(ConnectionIntent.WRITE, uri.getHost(), uri.getPort());
-
-            ConnectionFuture<StatefulRedisConnection<K, V>> future = getConnectionAsync(key);
-
-            return future.thenApply(connection -> {
+                        stateLock.lock();
+                        try {
+                            if (writers[slot] == null) {
+                                writers[slot] = CompletableFuture.completedFuture(connection);
+                            }
+                        } finally {
+                            stateLock.unlock();
+                        }
 
-                stateLock.lock();
-                try {
-                    if (writers[slot] == null) {
-                        writers[slot] = CompletableFuture.completedFuture(connection);
-                    }
-                } finally {
-                    stateLock.unlock();
+                        return connection;
+                    }).toCompletableFuture();
                 }
-
-                return connection;
-            }).toCompletableFuture();
+            } finally {
+                stateLock.unlock();
+            }
         }
 
-        return writer;
+        return writers[slot];
     }
 
     private CompletableFuture<StatefulRedisConnection<K, V>> getReadConnection(int slot) {