【无标题】

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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class DemandProcessor {

private static RedissonClient redissonClient;

// 初始化 Redisson 客户端
static {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");
    redissonClient = Redisson.create(config);
}

public static void main(String[] args) {
    List<String> demandIds = List.of("id1", "id2", "id3");

    // 尝试获取所有锁并创建流程
    boolean success = processDemandsWithLock(demandIds);

    if (success) {
        System.out.println("流程创建成功");
    } else {
        System.out.println("流程创建失败，锁定某些需求时失败");
    }

    // 关闭 Redisson 客户端
    redissonClient.shutdown();
}

public static boolean processDemandsWithLock(List<String> demandIds) {
    List<RLock> acquiredLocks = new ArrayList<>();

    try {
        // 为每个需求 ID 获取锁
        for (String demandId : demandIds) {
            RLock lock = redissonClient.getLock("demandLock:" + demandId);

            // 尝试获取锁，等待时间为 10 秒，锁超时自动释放时间为 30 秒
            if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
                acquiredLocks.add(lock); // 记录已经成功获取的锁
            } else {
                // 如果有一个锁获取失败，释放所有已经获取的锁
                System.out.println("无法获取锁: " + demandId);
                releaseLocks(acquiredLocks);
                return false;
            }
        }

        // 如果所有锁都获取成功，调用创建流程接口
        createProcess();

        return true;
    } catch (InterruptedException e) {
        e.printStackTrace();
        // 出现异常时释放所有已获取的锁
        releaseLocks(acquiredLocks);
        return false;
    } finally {
        // 最终释放所有锁
        releaseLocks(acquiredLocks);
    }
}

private static void createProcess() {
    // 模拟调用创建流程接口
    System.out.println("调用创建流程接口...");
}

import org.redisson.Redisson;

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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class DemandProcessor {

private static RedissonClient redissonClient;

// 初始化 Redisson 客户端
static {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");
    redissonClient = Redisson.create(config);
}

public static void main(String[] args) {
    List<String> demandIds = List.of("id1", "id2", "id3");

    // 尝试获取所有锁并创建流程
    boolean success = processDemandsWithLock(demandIds);

    if (success) {
        System.out.println("流程创建成功");
    } else {
        System.out.println("流程创建失败，锁定某些需求时失败");
    }

    // 关闭 Redisson 客户端
    redissonClient.shutdown();
}

public static boolean processDemandsWithLock(List<String> demandIds) {
    List<RLock> acquiredLocks = new ArrayList<>();

    try {
        // 为每个需求 ID 获取锁
        for (String demandId : demandIds) {
            RLock lock = redissonClient.getLock("demandLock:" + demandId);

            // 尝试获取锁，等待时间为 10 秒，锁超时自动释放时间为 30 秒
            if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
                acquiredLocks.add(lock); // 记录已经成功获取的锁
            } else {
                // 如果有一个锁获取失败，释放所有已经获取的锁
                System.out.println("无法获取锁: " + demandId);
                releaseLocks(acquiredLocks);
                return false;
            }
        }

        // 如果所有锁都获取成功，调用创建流程接口
        createProcess();

        return true;
    } catch (InterruptedException e) {
        e.printStackTrace();
        // 出现异常时释放所有已获取的锁
        releaseLocks(acquiredLocks);
        return false;
    } finally {
        // 最终释放所有锁
        releaseLocks(acquiredLocks);
    }
}

private static void createProcess() {
    // 模拟调用创建流程接口
    System.out.println("调用创建流程接口...");
    // 实际创建流程的逻辑
}

private static void releaseLocks(List<RLock> acquiredLocks) {
    for (RLock lock : acquiredLocks) {
        try {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        } catch (Exception e) {
            System.out.println("释放锁时出错: " + e.getMessage());
        }
    }
}

}

}

逐个获取锁：代码中使用 tryLock 方法尝试获取每个需求 ID 的锁。如果某个锁获取失败，则立即释放之前已经获取到的锁。

流程创建逻辑：在所有锁获取成功的情况下，调用 createProcess 方法模拟创建流程。

锁的释放：无论是在锁获取失败时还是在流程创建完毕后，所有成功获取的锁都需要被释放。这保证了锁的生命周期管理。

异常处理：在代码中使用了 try-catch-finally 来处理可能的异常，并确保在异常情况下释放所有锁。

并发控制：通过 Redisson 分布式锁机制，可以有效防止多个线程或进程同时操作相同的需求 ID，确保流程的原子性。

通过这种方式，你可以实现对多个需求 ID 的并发安全处理，并保证在锁获取失败的情况下能够安全回滚。