線上問題排查：記一次 Redis Cluster Pipeline 導致的死鎖問題

public T borrowObject(long borrowMaxWaitMillis) throws Exception {

    ...

    PooledObject<T> p = null;





    // 獲取blockWhenExhausted配置項，該配置預設值為true

    boolean blockWhenExhausted = getBlockWhenExhausted();





    boolean create;

    long waitTime = System.currentTimeMillis();





    while (p == null) {

        create = false;

        if (blockWhenExhausted) {

            // 從佇列獲取空閒的物件，該方法不會阻塞，沒有空閒物件會返回null

            p = idleObjects.pollFirst();

            // 沒有空閒物件則建立

            if (p == null) {

                p = create();

                if (p != null) {

                    create = true;

                }

            }

            if (p == null) {

                // borrowMaxWaitMillis預設值為-1

                if (borrowMaxWaitMillis < 0) {

                    // 執行緒棧快照裡所有的dubbo執行緒都卡在這裡，這是個阻塞方法，如果佇列裡沒有新的連線會一直等待下去

                    p = idleObjects.takeFirst();    

                } else {

                    // 等待borrowMaxWaitMillis配置的時間還沒有拿到連線的話就返回null

                    p = idleObjects.pollFirst(borrowMaxWaitMillis,

                            TimeUnit.MILLISECONDS);

                }

            }

            if (p == null) {

                throw new NoSuchElementException(

                        "Timeout waiting for idle object");

            }

            if (!p.allocate()) {

                p = null;

            }





        }





        ...





    }





    updateStatsBorrow(p, System.currentTimeMillis() - waitTime);





    return p.getObject();

}

private PooledObject<T> create() throws Exception {

    int localMaxTotal = getMaxTotal();

    long newCreateCount = createCount.incrementAndGet();

    if (localMaxTotal > -1 && newCreateCount > localMaxTotal ||

            newCreateCount > Integer.MAX_VALUE) {

        createCount.decrementAndGet();

        return null;

    }





    final PooledObject<T> p;

    try {

        // 建立redis連線，如果發生超時會丟擲異常

        // 預設的connectionTimeout和soTimeout都是2秒

        p = factory.makeObject();

    } catch (Exception e) {

        createCount.decrementAndGet();

        // 這裡會把異常繼續往上丟擲

        throw e;

    }





    AbandonedConfig ac = this.abandonedConfig;

    if (ac != null && ac.getLogAbandoned()) {

        p.setLogAbandoned(true);

    }





    createdCount.incrementAndGet();

    allObjects.put(new IdentityWrapper<T>(p.getObject()), p);

    return p;

}

public class JedisClusterPipline extends PipelineBase implements Closeable {





    private static final Logger log = LoggerFactory.getLogger(JedisClusterPipline.class);





    // 用於記錄redis命令的執行順序

    private final Queue<Client> orderedClients = new LinkedList<>();

    // redis連線快取

    private final Map<JedisPool, Jedis> poolToJedisMap = new HashMap<>();





    private final JedisSlotBasedConnectionHandler connectionHandler;

    private final JedisClusterInfoCache clusterInfoCache;





    public JedisClusterPipline(JedisSlotBasedConnectionHandler connectionHandler, JedisClusterInfoCache clusterInfoCache) {

        this.connectionHandler = connectionHandler;

        this.clusterInfoCache = clusterInfoCache;

    }





    @Override

    protected Client getClient(String key) {





        return getClient(SafeEncoder.encode(key));

    }





    @Override

    protected Client getClient(byte[] key) {





        Client client;

        // 計算key所在的slot

        int slot = JedisClusterCRC16.getSlot(key);

        // 獲取solt對應的連線池

        JedisPool pool = clusterInfoCache.getSlotPool(slot);

        // 從快取獲取連線

        Jedis borrowedJedis = poolToJedisMap.get(pool);

        // 快取中沒有連線則從連線池獲取並快取

        if (null == borrowedJedis) {

            borrowedJedis = pool.getResource();

            poolToJedisMap.put(pool, borrowedJedis);

        }





        client = borrowedJedis.getClient();





        orderedClients.add(client);





        return client;

    }





    @Override

    public void close() {

        for (Jedis jedis : poolToJedisMap.values()) {

            // 清除連線內的殘留資料,防止連線歸還時有資料漏讀的現象

            try {

                jedis.getClient().getAll();

            } catch (Throwable throwable) {

                log.warn("關閉jedis時遍歷異常，遍歷的目的是：清除連線內的殘留資料,防止連線歸還時有資料漏讀的現象");

            }

            try {

                jedis.close();

            } catch (Throwable throwable) {

                log.warn("關閉jedis異常");

            }

        }

        // 歸還連線

        clean();

        orderedClients.clear();

        poolToJedisMap.clear();

    }





    /**

     * go through all the responses and generate the right response type (warning :

     * usually it is a waste of time).

     *

     * @return A list of all the responses in the order

     */

    public List<Object> syncAndReturnAll() {

        List<Object> formatted = new ArrayList<>();

        List<Throwable> throwableList = new ArrayList<>();

        for (Client client : orderedClients) {

            try {

                Response response = generateResponse(client.getOne());

                if(response == null){

                    continue;

                }

                formatted.add(response.get());

            } catch (Throwable e) {

                throwableList.add(e);

            }

        }

        slotCacheRefreshed(throwableList);

        return formatted;

    }

}

0x6a578e0c80x6a578e0480x6a578ddc80x6a578e5380x6a578e838