private static final ReentrantLock lock=new ReentrantLock();

public void doSomething() {
    lock.lock(); // 加锁
    try {
        // 临界区：同一JVM内仅一线程执行
    } finally {
        lock.unlock(); // 释放
    }
}

String key="lock:product:1001";
// NX：不存在才设；EX：10秒过期
boolean ok=redisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
if (ok) {
    try {
        // 分布式临界区：多服务仅一个执行
    } finally {
        redisTemplate.delete(key); // 释放
    }
}

RLock lock=redissonClient.getLock("lock:product:1001");
lock.lock(); // 看门狗自动续期（默认30秒）
try {
    // 业务
} finally {
    lock.unlock();
}

// 错误写法
lock.lock();
// 业务代码异常 → 无法解锁
lock.unlock();

// 错误：字符串重新赋值，锁对象变了
private String lockObj = "lock";
synchronized (lockObj) {
    lockObj = "newLock"; 
}

redis.set(key,val);
redis.expire(key,10);

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component
public class RedisDistributedLock {

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    // 锁过期时间，根据业务调整
    private static final long LOCK_EXPIRE_TIME = 30;
    private static final TimeUnit TIME_UNIT = TimeUnit.SECONDS;

    // 解锁Lua脚本：判断value一致才删除
    private static final String UNLOCK_LUA_SCRIPT =
            "if redis.call('get',KEYS[1]) == ARGV[1] then " +
            "return redis.call('del',KEYS[1]) " +
            "else return 0 end";

    /**
     * 加锁
     * @param lockKey 锁标识
     * @return 成功返回唯一标识，失败返回null
     */
    public String lock(String lockKey) {
        // 唯一标识，防止误删
        String lockValue = UUID.randomUUID().toString();
        // NX:不存在才上锁  EX:自动过期
        boolean success = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, lockValue, LOCK_EXPIRE_TIME, TIME_UNIT);
        return success ? lockValue : null;
    }

    /**
     * 解锁
     * @param lockKey 锁标识
     * @param lockValue 加锁时返回的唯一标识
     */
    public void unlock(String lockKey, String lockValue) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(UNLOCK_LUA_SCRIPT);
        script.setResultType(Long.class);
        // 原子执行：校验+删除
        redisTemplate.execute(script, Collections.singletonList(lockKey), lockValue);
    }
}

@Service
public class BusinessService {

    @Resource
    private RedisDistributedLock redisDistributedLock;

    public void seckillGoods(Long goodsId) {
        String lockKey = "lock:goods:" + goodsId;
        String lockValue = null;
        try {
            // 尝试加锁
            lockValue = redisDistributedLock.lock(lockKey);
            if (lockValue == null) {
                // 加锁失败，直接返回/重试
                throw new RuntimeException("操作频繁，请稍后再试");
            }
            // --------------- 临界区业务 ---------------
            // 库存扣减、订单创建、防重复提交等
            // -----------------------------------------
        } finally {
            // 必须解锁
            if (lockValue != null) {
                redisDistributedLock.unlock(lockKey, lockValue);
            }
        }
    }
}

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.5</version>
</dependency>

@Service
public class RedissonLockService {

    @Resource
    private RedissonClient redissonClient;

    public void doBiz(Long resourceId) {
        String lockKey = "lock:biz:" + resourceId;
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 无参lock：看门狗续期，适合长耗时业务
            lock.lock();

            // --------------- 业务代码 ---------------

        } finally {
            // 释放锁
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

// 1. 阻塞加锁，看门狗自动续期（常用）
lock.lock();

// 2. 尝试获取锁，等待5秒，锁15秒自动过期
boolean tryLock = lock.tryLock(5, 15, TimeUnit.SECONDS);