如何在Java中使用Redis事务和分布式锁来避免死锁，并确保在并发环境下数据的一致性和操作的原子性。

示例背景

假设我们有一个简单的库存管理系统，当用户尝试购买商品时，我们需要减少库存数量。我们将使用Redis事务来确保库存更新的原子性，并使用分布式锁来避免并发请求导致的死锁。

使用Redis事务更新库存

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class InventoryManager {

    private Jedis jedis;

    public InventoryManager(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean purchaseItem(String itemKey, int quantityToPurchase) {
        // 检查库存是否足够
        int currentStock = Integer.parseInt(jedis.get(itemKey));
        if (currentStock < quantityToPurchase) {
            System.out.println("库存不足，无法购买。");
            return false;
        }

        // 开始事务
        Transaction transaction = jedis.multi();
        transaction.decrBy(itemKey, quantityToPurchase);
        // 执行事务
        transaction.exec();

        System.out.println("购买成功，库存已更新。");
        return true;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        InventoryManager manager = new InventoryManager(jedis);
        
        // 假设商品键为"item:123"，尝试购买3个单位
        String itemKey = "item:123";
        int quantityToPurchase = 3;
        
        boolean purchaseResult = manager.purchaseItem(itemKey, quantityToPurchase);
        
        jedis.close();
    }
}

使用Redis分布式锁

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {

    private Jedis jedis;

    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean lock(String lockKey, String requestId, int expireTime) {
        String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
        return "OK".equals(result);
    }

    public boolean unlock(String lockKey, String requestId) {
        String script =
                "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                "return redis.call('del', KEYS[1]) " +
                "else " +
                "return 0 " +
                "end";
        Object result = jedis.eval(script, 1, lockKey, requestId);
        return "1".equals(result.toString());
    }
    
    // 使用锁来保护库存更新操作
    public void purchaseItemWithLock(InventoryManager manager, String itemKey, int quantityToPurchase) {
        String lockKey = "lock:" + itemKey;
        String requestId = java.util.UUID.randomUUID().toString();
        int expireTime = 30000; // 锁超时时间30秒

        if (lock(lockKey, requestId, expireTime)) {
            try {
                manager.purchaseItem(itemKey, quantityToPurchase);
            } finally {
                unlock(lockKey, requestId);
            }
        } else {
            System.out.println("无法获取锁，请稍后再试。");
        }
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        RedisDistributedLock lock = new RedisDistributedLock(jedis);
        InventoryManager manager = new InventoryManager(jedis);
        
        // 假设商品键为"item:123"，尝试购买3个单位
        String itemKey = "item:123";
        int quantityToPurchase = 3;
        
        lock.purchaseItemWithLock(manager, itemKey, quantityToPurchase);
        
        jedis.close();
    }
}

在这个示例中，我们创建了一个InventoryManager类来处理库存更新，并在RedisDistributedLock类中使用分布式锁来保护库存更新操作。这样，即使在多线程或多服务器环境中，也能保证库存更新的原子性和一致性，避免了死锁的发生。