高并发环境下安全修改同一行数据库数据的策略分享

Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
    conn = dataSource.getConnection();
    //关闭自动提交
    conn.setAutoCommit(false);
    //SELECT ... FOR UPDATE是悲观锁的典型应用，此时会锁住被选中的行，其他事务无法更新这些行
    String sql = "SELECT * FROM product WHERE id = ? FOR UPDATE";
    ps = conn.prepareStatement(sql);
    ps.setInt(1, 1);
    rs = ps.executeQuery();
    if (rs.next()) {
        //获取当前库存数量
        int count = rs.getInt("count");
        if (count > 0) {
            String updateSql = "UPDATE product SET count = count - 1 WHERE id = ?";
            ps = conn.prepareStatement(updateSql);
            ps.setInt(1, 1);
            ps.executeUpdate();
            conn.commit();
            System.out.println("扣减成功，剩余库存：" + (count - 1));
        } else {
            System.out.println("库存不足，扣减失败");
        }
    }
} catch (Exception e) {
    if (conn != null) {
        try {
            //如果出现异常，进行回滚
            conn.rollback();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
    }
    e.printStackTrace();
} finally {
    //在最后，关闭资源
    if (rs != null) {
        try {
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (ps != null) {
        try {
            ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

import javax.persistence.*;
@Entity
@Data
public class Product {
    @Id
    @GeneratedValue
    private Long id;
    private Integer count;
    //版本号，用于实现乐观锁
    @Version
    private Integer version;
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional
    public void reduceCount(Long productId) {
        //找到产品
        Product product = productRepository.findById(productId).get();
        //检查库存
        if (product.getCount() > 0) {
            //如果库存足够，减少库存
            product.setCount(product.getCount() - 1);
            productRepository.save(product);
        } else {
            //库存不足，抛出异常
            throw new RuntimeException("库存不足");
        }
    }
}

// 使用 Redisson 库实现 Redis 分布式锁
RedissonClient redisson = Redisson.create();
RLock lock = redisson.getLock("myLock");
try{
    lock.lock();
    // 执行业务操作
}finally{
    lock.unlock();
}