spring-data-redis源码分析备忘

在DefaultRedisCacheWriter中的读取过程中

    private <T> T execute(String name, Function<RedisConnection, T> callback) {

        RedisConnection connection = connectionFactory.getConnection();
        try {

            checkAndPotentiallyWaitUntilUnlocked(name, connection);//实现redis分布式锁检验
            return callback.apply(connection);
        } finally {
            connection.close();
        }

    }

private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection connection) {//锁的过程是阻塞的

		if (!isLockingCacheWriter()) {
/**return !sleepTime.isZero() && !sleepTime.isNegative();具体实现是这样的，如果config配置时没有设置超时时间，或格式不合法，不进行锁检验

                     return;
		}

		try {

			while (doCheckLock(name, connection)) {
				Thread.sleep(sleepTime.toMillis());
			}
		} catch (InterruptedException ex) {

			// Re-interrupt current thread, to allow other participants to react.
			Thread.currentThread().interrupt();

			throw new PessimisticLockingFailureException(String.format("Interrupted while waiting to unlock cache %s", name),
					ex);
		}
	}

总之正常情况下，如果配置了锁时间，在读的过程中就会阻塞等待。

在put时不会进行加锁，只会在putIfAbsent进行，在完成前后进行加锁，释放操作

@Override
	public byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Duration ttl) {

		Assert.notNull(name, "Name must not be null!");
		Assert.notNull(key, "Key must not be null!");
		Assert.notNull(value, "Value must not be null!");

		return execute(name, connection -> {

			if (isLockingCacheWriter()) {
				doLock(name, connection);
			}

			try {
				if (connection.setNX(key, value)) {

					if (shouldExpireWithin(ttl)) {
						connection.pExpire(key, ttl.toMillis());
					}
					return null;
				}

				return connection.get(key);
			} finally {

				if (isLockingCacheWriter()) {
					doUnlock(name, connection);
				}
			}
		});
	}