悲观锁、乐观锁与分布式锁详解及Redisson应用

在多线程或多进程环境下，为了保证数据的一致性，锁机制扮演着至关重要的角色。本文将深入探讨悲观锁、乐观锁的概念，以及如何利用Redis实现分布式锁，并通过Redisson客户端展示具体的应用实例。最后，我们也会简要提及如何从Redis中删除缓存信息。

1. 悲观锁（Pessimistic Lock）

概念： 悲观锁假设最坏的情况，即每次数据操作都可能发生并发冲突，因此在数据被处理前就将其锁定，阻止其他线程访问，直到该线程完成操作并释放锁。这种方式适合写操作频繁的场景。
Java中的应用： 在Java中，synchronized关键字和ReentrantLock类可以用来实现悲观锁。

public class PessimisticLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void doSomething() {
        lock.lock(); // 获取锁
        try {
            // 执行业务逻辑
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

2. 乐观锁（Optimistic Lock）

概念： 乐观锁则假设读多写少的情况，不直接加锁，而是在更新数据时检查在此期间数据是否被其他线程修改过。乐观锁常通过版本号或时间戳来实现，仅当数据实际需要更新时才进行冲突检查。
Java中的应用： 在数据库操作中，可以通过版本字段实现乐观锁。

@Entity
class User {
    @Version
    private Long version;

    // 省略其他代码...
}

// 更新用户信息时检查版本号
@Modifying
@Query("UPDATE User u SET u.name = ?1 WHERE u.id = ?2 AND u.version = ?3")
int updateUser(String newName, Long id, Long version);

3. Redis分布式锁

概念： 在分布式系统中，传统的锁机制无法跨越多个节点，因此需要分布式锁。Redis由于其高性能和易用性，常被用作分布式锁的实现基础。
基本用法：
SETNX (SET if Not eXists) 命令可以用来实现简单的分布式锁。
需要考虑锁的超时释放问题，使用 expire 命令设置锁的生存时间。

@RequiredArgsConstructor
public class RedisLock {

    private final String key;
    private final StringRedisTemplate redisTemplate;

    public boolean lock(long leaseTime, TimeUnit timeUnit) {
        String value = Thread.currentThread().getName();
        Boolean success = redisTemplate.opsForValue().setIfAbsent(key, value, leaseTime, timeUnit);
        return BooleanUtils.isTrue(success);
    }
    public void unlock() {
            redisTemplate.delete(key);

    }
}

        String key="lock:coupon:userId:"+userId;
        RedisLock redisLock = new RedisLock(key, redisTemplate);
        boolean locked = redisLock.lock(5, TimeUnit.SECONDS);
        if(!locked)
        {
            throw new BadRequestException("请求太频繁");
        }
        try {
            // 获取用户优惠券服务
            IUserCouponService userCouponService = (IUserCouponService) AopContext.currentProxy();
            // 校验并创建用户优惠券
            userCouponService.checkAndCreateUserCoupon(coupon, userId, null);
        } finally {
            redisLock.unlock();
        }

4. Redisson锁

Redisson是Redis的Java客户端，它提供了丰富的并发工具，包括基于Redis的分布式锁、信号量、计数器等高级功能，简化了分布式环境下的并发控制。
Redisson分布式锁示例：

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

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

        RLock lock = redisson.getLock("myLock");
        
        try {
            // 尝试获取锁，最多等待100秒，上锁后自动续期
            boolean isLocked = lock.tryLock(100, TimeUnit.SECONDS);
            if (isLocked) {
                // 执行业务逻辑
            } else {
                System.out.println("未能获取到锁");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        redisson.shutdown();
    }
}

通过上述介绍和示例，我们可以看到，悲观锁、乐观锁以及分布式锁（特别是通过Redisson实现）在不同场景下各有优势，选择合适的锁机制对于提升系统并发性能和数据一致性至关重要。