使用Redis实现分布式锁与缓存策略方式

import redis.clients.jedis.Jedis;

public class RedisLockExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "resource_lock";
        String value = "lock_value";
        int expireTime = 100; // 过期时间，单位秒

        if (jedis.setnx(key, value) == 1) {
            jedis.expire(key, expireTime);
            try {
                // 业务代码
                System.out.println("获取锁成功，执行业务逻辑");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                jedis.del(key);
                System.out.println("释放锁");
            }
        } else {
            System.out.println("获取锁失败");
        }
        jedis.close();
    }
}

- **缺点**：`SETNX`和`EXPIRE`两个命令不是原子操作，如果在执行完`SETNX`后，进程崩溃或重启，`EXPIRE`命令未执行，锁将无法释放，导致其他客户端永远无法获取锁。

import redis.clients.jedis.Jedis;

public class RedisLockWithTimeExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "resource_lock";
        long expireTime = 10000; // 过期时间，单位毫秒

        long expires = System.currentTimeMillis() + expireTime;
        String expiresStr = String.valueOf(expires);

        if (jedis.setnx(key, expiresStr) == 1) {
            System.out.println("获取锁成功");
        } else {
            String currentValueStr = jedis.get(key);
            if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
                String oldValueStr = jedis.getSet(key, expiresStr);
                if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                    System.out.println("获取锁成功");
                } else {
                    System.out.println("获取锁失败，其他线程已更新锁");
                }
            } else {
                System.out.println("获取锁失败，锁未过期");
            }
        }
        jedis.close();
    }
}

- **缺点**：过期时间是客户端自己生成的，依赖系统时间，要求分布式环境下每个客户端的时间必须同步。锁过期时，并发多个客户端同时请求，都执行`getSet`，最终只有一个客户端加锁成功，但该客户端锁的过期时间可能被别的客户端覆盖。且该锁没有保存持有者的唯一标识，可能被别的客户端释放。

import redis.clients.jedis.Jedis;
import java.util.Collections;

public class RedisLockWithLuaExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "resource_lock";
        String value = "lock_value";
        int expireTime = 100; // 过期时间，单位秒

        String luaScript = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
                "redis.call('expire', KEYS[1], ARGV[2]) " +
                "else " +
                "return 0 " +
                "end";

        Object result = jedis.eval(luaScript, Collections.singletonList(key),
                Collections.singletonList(value + "," + expireTime));

        if (result.equals(1L)) {
            System.out.println("获取锁成功");
            try {
                // 业务代码
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                jedis.del(key);
                System.out.println("释放锁");
            }
        } else {
            System.out.println("获取锁失败");
        }
        jedis.close();
    }
}

import redis.clients.jedis.Jedis;

public class RedisSetLockExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String key = "resource_lock";
        String value = "lock_value";
        int expireTime = 100; // 过期时间，单位秒

        String result = jedis.set(key, value, "NX", "EX", expireTime);

        if ("OK".equals(result)) {
            System.out.println("获取锁成功");
            try {
                // 业务代码
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                jedis.del(key);
                System.out.println("释放锁");
            }
        } else {
            System.out.println("获取锁失败");
        }
        jedis.close();
    }
}

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonLockExample {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        RedissonClient redissonClient = Redisson.create(config);

        RLock lock = redissonClient.getLock("resource_lock");

        try {
            boolean isLocked = lock.tryLock(10, 30, java.util.concurrent.TimeUnit.SECONDS);
            if (isLocked) {
                System.out.println("获取锁成功");
                // 业务代码
            } else {
                System.out.println("获取锁失败");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            redissonClient.shutdown();
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserServiceCacheAside {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private UserRepository userRepository;
    private static final String CACHE_KEY_PREFIX = "user:";
    private static final long CACHE_EXPIRATION = 30; // 缓存过期时间（分钟）

    public User getUserById(Long userId) {
        String cacheKey = CACHE_KEY_PREFIX + userId;
        // 1. 查询缓存
        User user = (User) redisTemplate.opsForValue().get(cacheKey);
        // 2. 缓存命中，直接返回
        if (user != null) {
            return user;
        }
        // 3. 缓存未命中，查询数据库
        user = userRepository.findById(userId).orElse(null);
        // 4. 将数据库结果写入缓存（设置过期时间）
        if (user != null) {
            redisTemplate.opsForValue().set(cacheKey, user, CACHE_EXPIRATION, java.util.concurrent.TimeUnit.MINUTES);
        }
        return user;
    }

    public void updateUser(User user) {
        // 1. 先更新数据库
        userRepository.save(user);
        // 2. 再删除缓存
        String cacheKey = CACHE_KEY_PREFIX + user.getId();
        redisTemplate.delete(cacheKey);
    }
}