第77集Java锁并发控制与锁优化实战

/**
 * Java锁配置类
 */
@Configuration
public class JavaLockConfig {
    
    @Value("${java-lock.default-timeout:30}")
    private int defaultTimeout;
    
    @Value("${java-lock.max-wait-time:60}")
    private int maxWaitTime;
    
    /**
     * Java锁配置属性
     */
    @Bean
    public JavaLockProperties javaLockProperties() {
        return JavaLockProperties.builder()
            .defaultTimeout(defaultTimeout)
            .maxWaitTime(maxWaitTime)
            .build();
    }
    
    /**
     * 锁管理器
     */
    @Bean
    public LockManager lockManager() {
        return new LockManager(javaLockProperties());
    }
    
    /**
     * 死锁检测器
     */
    @Bean
    public DeadlockDetector deadlockDetector() {
        return new DeadlockDetector(javaLockProperties());
    }
    
    /**
     * 锁性能监控器
     */
    @Bean
    public LockPerformanceMonitor lockPerformanceMonitor() {
        return new LockPerformanceMonitor(javaLockProperties());
    }
}

/**
 * Java锁配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class JavaLockProperties {
    private int defaultTimeout;
    private int maxWaitTime;
    
    // 锁优化配置
    private boolean enableLockOptimization = true;
    private boolean enableBiasLock = true;
    private boolean enableLockElimination = true;
    private boolean enableLockCoarsening = true;
    
    // 死锁检测配置
    private boolean enableDeadlockDetection = true;
    private int deadlockDetectionInterval = 5; // 秒
    private int maxDeadlockRetries = 3;
    
    // 性能监控配置
    private boolean enablePerformanceMonitoring = true;
    private int monitoringInterval = 60; // 秒
    private boolean enableLockContentionMonitoring = true;
}

/**
 * 锁管理器
 */
@Component
public class LockManager {
    
    private final JavaLockProperties properties;
    private final Map<String, ReentrantLock> locks = new ConcurrentHashMap<>();
    private final Map<String, ReadWriteLock> readWriteLocks = new ConcurrentHashMap<>();
    private final Map<String, StampedLock> stampedLocks = new ConcurrentHashMap<>();
    
    public LockManager(JavaLockProperties properties) {
        this.properties = properties;
    }
    
    /**
     * 获取可重入锁
     * @param lockName 锁名称
     * @return 可重入锁
     */
    public ReentrantLock getReentrantLock(String lockName) {
        return locks.computeIfAbsent(lockName, k -> new ReentrantLock());
    }
    
    /**
     * 获取读写锁
     * @param lockName 锁名称
     * @return 读写锁
     */
    public ReadWriteLock getReadWriteLock(String lockName) {
        return readWriteLocks.computeIfAbsent(lockName, k -> new ReentrantReadWriteLock());
    }
    
    /**
     * 获取戳锁
     * @param lockName 锁名称
     * @return 戳锁
     */
    public StampedLock getStampedLock(String lockName) {
        return stampedLocks.computeIfAbsent(lockName, k -> new StampedLock());
    }
    
    /**
     * 使用可重入锁执行任务
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithReentrantLock(String lockName, Supplier<T> task) {
        ReentrantLock lock = getReentrantLock(lockName);
        try {
            if (lock.tryLock(properties.getDefaultTimeout(), TimeUnit.SECONDS)) {
                try {
                    return task.get();
                } finally {
                    lock.unlock();
                }
            } else {
                throw new LockTimeoutException("获取锁超时: " + lockName);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new LockInterruptedException("获取锁被中断: " + lockName, e);
        }
    }
    
    /**
     * 使用读写锁执行读任务
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithReadLock(String lockName, Supplier<T> task) {
        ReadWriteLock lock = getReadWriteLock(lockName);
        Lock readLock = lock.readLock();
        try {
            if (readLock.tryLock(properties.getDefaultTimeout(), TimeUnit.SECONDS)) {
                try {
                    return task.get();
                } finally {
                    readLock.unlock();
                }
            } else {
                throw new LockTimeoutException("获取读锁超时: " + lockName);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new LockInterruptedException("获取读锁被中断: " + lockName, e);
        }
    }
    
    /**
     * 使用读写锁执行写任务
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithWriteLock(String lockName, Supplier<T> task) {
        ReadWriteLock lock = getReadWriteLock(lockName);
        Lock writeLock = lock.writeLock();
        try {
            if (writeLock.tryLock(properties.getDefaultTimeout(), TimeUnit.SECONDS)) {
                try {
                    return task.get();
                } finally {
                    writeLock.unlock();
                }
            } else {
                throw new LockTimeoutException("获取写锁超时: " + lockName);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new LockInterruptedException("获取写锁被中断: " + lockName, e);
        }
    }
    
    /**
     * 使用戳锁执行乐观读任务
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithOptimisticRead(String lockName, Function<Long, T> task) {
        StampedLock lock = getStampedLock(lockName);
        long stamp = lock.tryOptimisticRead();
        if (stamp != 0) {
            T result = task.apply(stamp);
            if (lock.validate(stamp)) {
                return result;
            }
        }
        
        // 乐观读失败，降级为悲观读
        stamp = lock.readLock();
        try {
            return task.apply(stamp);
        } finally {
            lock.unlockRead(stamp);
        }
    }
    
    /**
     * 使用戳锁执行写任务
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithWriteLock(String lockName, Supplier<T> task) {
        StampedLock lock = getStampedLock(lockName);
        long stamp = lock.writeLock();
        try {
            return task.get();
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

/**
 * 锁超时异常
 */
public class LockTimeoutException extends RuntimeException {
    public LockTimeoutException(String message) {
        super(message);
    }
}

/**
 * 锁中断异常
 */
public class LockInterruptedException extends RuntimeException {
    public LockInterruptedException(String message, Throwable cause) {
        super(message, cause);
    }
}

/**
 * 锁优化服务
 */
@Service
public class LockOptimizationService {
    
    private final JavaLockProperties properties;
    private final LockManager lockManager;
    
    public LockOptimizationService(JavaLockProperties properties) {
        this.properties = properties;
        this.lockManager = null; // 注入
    }
    
    /**
     * 锁粗化优化
     * @param tasks 任务列表
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> List<T> executeWithLockCoarsening(String lockName, List<Supplier<T>> tasks) {
        if (!properties.isEnableLockCoarsening()) {
            return executeWithoutLockCoarsening(lockName, tasks);
        }
        
        return lockManager.executeWithReentrantLock(lockName, () -> {
            List<T> results = new ArrayList<>();
            for (Supplier<T> task : tasks) {
                results.add(task.get());
            }
            return results;
        });
    }
    
    /**
     * 无锁粗化执行
     * @param tasks 任务列表
     * @param <T> 返回类型
     * @return 执行结果
     */
    private <T> List<T> executeWithoutLockCoarsening(String lockName, List<Supplier<T>> tasks) {
        List<T> results = new ArrayList<>();
        for (Supplier<T> task : tasks) {
            T result = lockManager.executeWithReentrantLock(lockName, task);
            results.add(result);
        }
        return results;
    }
    
    /**
     * 锁消除优化
     * @param data 数据
     * @param operation 操作
     * @param <T> 数据类型
     * @return 处理结果
     */
    public <T> T executeWithLockElimination(T data, Function<T, T> operation) {
        if (!properties.isEnableLockElimination()) {
            return executeWithoutLockElimination(data, operation);
        }
        
        // 检查是否可以消除锁
        if (canEliminateLock(data)) {
            return operation.apply(data);
        }
        
        return executeWithoutLockElimination(data, operation);
    }
    
    /**
     * 无锁消除执行
     * @param data 数据
     * @param operation 操作
     * @param <T> 数据类型
     * @return 处理结果
     */
    private <T> T executeWithoutLockElimination(T data, Function<T, T> operation) {
        String lockName = "data_" + data.hashCode();
        return lockManager.executeWithReentrantLock(lockName, () -> operation.apply(data));
    }
    
    /**
     * 检查是否可以消除锁
     * @param data 数据
     * @param <T> 数据类型
     * @return 是否可以消除锁
     */
    private <T> boolean canEliminateLock(T data) {
        // 实现锁消除判断逻辑
        // 例如：检查数据是否被其他线程访问
        return Thread.currentThread().getName().contains("main");
    }
    
    /**
     * 偏向锁优化
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithBiasLock(String lockName, Supplier<T> task) {
        if (!properties.isEnableBiasLock()) {
            return lockManager.executeWithReentrantLock(lockName, task);
        }
        
        // 偏向锁优化：检查是否可以使用偏向锁
        if (canUseBiasLock(lockName)) {
            return executeWithBiasLockInternal(lockName, task);
        }
        
        return lockManager.executeWithReentrantLock(lockName, task);
    }
    
    /**
     * 内部偏向锁执行
     * @param lockName 锁名称
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    private <T> T executeWithBiasLockInternal(String lockName, Supplier<T> task) {
        // 实现偏向锁逻辑
        // 偏向锁通常由JVM自动处理，这里只是示例
        return task.get();
    }
    
    /**
     * 检查是否可以使用偏向锁
     * @param lockName 锁名称
     * @return 是否可以使用偏向锁
     */
    private boolean canUseBiasLock(String lockName) {
        // 实现偏向锁判断逻辑
        // 例如：检查锁的竞争情况
        return true;
    }
    
    /**
     * 锁升级优化
     * @param lockName 锁名称
     * @param readTask 读任务
     * @param writeTask 写任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithLockUpgrade(String lockName, Supplier<T> readTask, Supplier<T> writeTask) {
        // 先尝试读锁
        try {
            return lockManager.executeWithReadLock(lockName, readTask);
        } catch (LockTimeoutException e) {
            // 读锁超时，升级为写锁
            log.warn("读锁超时，升级为写锁: {}", lockName);
            return lockManager.executeWithWriteLock(lockName, writeTask);
        }
    }
}

/**
 * 死锁检测器
 */
@Component
public class DeadlockDetector {
    
    private final JavaLockProperties properties;
    private final Map<String, LockInfo> lockInfos = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    
    public DeadlockDetector(JavaLockProperties properties) {
        this.properties = properties;
        if (properties.isEnableDeadlockDetection()) {
            startDeadlockDetection();
        }
    }
    
    /**
     * 开始死锁检测
     */
    private void startDeadlockDetection() {
        scheduler.scheduleAtFixedRate(
            this::detectDeadlock,
            properties.getDeadlockDetectionInterval(),
            properties.getDeadlockDetectionInterval(),
            TimeUnit.SECONDS
        );
    }
    
    /**
     * 检测死锁
     */
    private void detectDeadlock() {
        try {
            // 1. 获取所有线程的锁信息
            Map<Thread, Set<String>> threadLocks = getThreadLockInfo();
            
            // 2. 构建等待图
            Map<String, Set<String>> waitGraph = buildWaitGraph(threadLocks);
            
            // 3. 检测循环等待
            List<List<String>> cycles = detectCycles(waitGraph);
            
            // 4. 处理死锁
            if (!cycles.isEmpty()) {
                handleDeadlock(cycles);
            }
            
        } catch (Exception e) {
            log.error("死锁检测失败", e);
        }
    }
    
    /**
     * 获取线程锁信息
     * @return 线程锁信息
     */
    private Map<Thread, Set<String>> getThreadLockInfo() {
        Map<Thread, Set<String>> threadLocks = new HashMap<>();
        
        for (Map.Entry<String, LockInfo> entry : lockInfos.entrySet()) {
            String lockName = entry.getKey();
            LockInfo lockInfo = entry.getValue();
            
            if (lockInfo.getOwnerThread() != null) {
                threadLocks.computeIfAbsent(lockInfo.getOwnerThread(), k -> new HashSet<>())
                    .add(lockName);
            }
        }
        
        return threadLocks;
    }
    
    /**
     * 构建等待图
     * @param threadLocks 线程锁信息
     * @return 等待图
     */
    private Map<String, Set<String>> buildWaitGraph(Map<Thread, Set<String>> threadLocks) {
        Map<String, Set<String>> waitGraph = new HashMap<>();
        
        for (Map.Entry<Thread, Set<String>> entry : threadLocks.entrySet()) {
            Thread thread = entry.getKey();
            Set<String> locks = entry.getValue();
            
            for (String lock : locks) {
                LockInfo lockInfo = lockInfos.get(lock);
                if (lockInfo != null && lockInfo.getWaitingThreads() != null) {
                    for (Thread waitingThread : lockInfo.getWaitingThreads()) {
                        Set<String> waitingLocks = threadLocks.get(waitingThread);
                        if (waitingLocks != null) {
                            waitGraph.computeIfAbsent(lock, k -> new HashSet<>())
                                .addAll(waitingLocks);
                        }
                    }
                }
            }
        }
        
        return waitGraph;
    }
    
    /**
     * 检测循环等待
     * @param waitGraph 等待图
     * @return 循环列表
     */
    private List<List<String>> detectCycles(Map<String, Set<String>> waitGraph) {
        List<List<String>> cycles = new ArrayList<>();
        Set<String> visited = new HashSet<>();
        Set<String> recursionStack = new HashSet<>();
        
        for (String node : waitGraph.keySet()) {
            if (!visited.contains(node)) {
                List<String> cycle = new ArrayList<>();
                if (hasCycle(node, waitGraph, visited, recursionStack, cycle)) {
                    cycles.add(new ArrayList<>(cycle));
                }
            }
        }
        
        return cycles;
    }
    
    /**
     * 检查是否有循环
     * @param node 节点
     * @param waitGraph 等待图
     * @param visited 已访问
     * @param recursionStack 递归栈
     * @param cycle 循环
     * @return 是否有循环
     */
    private boolean hasCycle(String node, Map<String, Set<String>> waitGraph, 
                           Set<String> visited, Set<String> recursionStack, List<String> cycle) {
        visited.add(node);
        recursionStack.add(node);
        cycle.add(node);
        
        Set<String> neighbors = waitGraph.get(node);
        if (neighbors != null) {
            for (String neighbor : neighbors) {
                if (!visited.contains(neighbor)) {
                    if (hasCycle(neighbor, waitGraph, visited, recursionStack, cycle)) {
                        return true;
                    }
                } else if (recursionStack.contains(neighbor)) {
                    return true;
                }
            }
        }
        
        recursionStack.remove(node);
        cycle.remove(node);
        return false;
    }
    
    /**
     * 处理死锁
     * @param cycles 循环列表
     */
    private void handleDeadlock(List<List<String>> cycles) {
        log.error("检测到死锁: {}", cycles);
        
        for (List<String> cycle : cycles) {
            // 选择中断一个线程来打破死锁
            String lockToRelease = cycle.get(0);
            LockInfo lockInfo = lockInfos.get(lockToRelease);
            
            if (lockInfo != null && lockInfo.getOwnerThread() != null) {
                Thread threadToInterrupt = lockInfo.getOwnerThread();
                log.warn("中断线程以打破死锁: thread={}, lock={}", threadToInterrupt.getName(), lockToRelease);
                threadToInterrupt.interrupt();
            }
        }
    }
    
    /**
     * 注册锁信息
     * @param lockName 锁名称
     * @param lockInfo 锁信息
     */
    public void registerLockInfo(String lockName, LockInfo lockInfo) {
        lockInfos.put(lockName, lockInfo);
    }
    
    /**
     * 注销锁信息
     * @param lockName 锁名称
     */
    public void unregisterLockInfo(String lockName) {
        lockInfos.remove(lockName);
    }
}

/**
 * 锁信息
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LockInfo {
    private String lockName;
    private Thread ownerThread;
    private Set<Thread> waitingThreads;
    private LocalDateTime createTime;
    private LocalDateTime lastAccessTime;
}

/**
 * 并发控制服务
 */
@Service
public class ConcurrencyControlService {
    
    private final LockManager lockManager;
    private final DeadlockDetector deadlockDetector;
    
    public ConcurrencyControlService() {
        this.lockManager = null; // 注入
        this.deadlockDetector = null; // 注入
    }
    
    /**
     * 原子操作
     * @param data 数据
     * @param operation 操作
     * @param <T> 数据类型
     * @return 操作结果
     */
    public <T> T executeAtomicOperation(T data, Function<T, T> operation) {
        String lockName = "atomic_" + data.hashCode();
        
        return lockManager.executeWithReentrantLock(lockName, () -> {
            // 注册锁信息
            LockInfo lockInfo = new LockInfo(
                lockName,
                Thread.currentThread(),
                new HashSet<>(),
                LocalDateTime.now(),
                LocalDateTime.now()
            );
            deadlockDetector.registerLockInfo(lockName, lockInfo);
            
            try {
                return operation.apply(data);
            } finally {
                deadlockDetector.unregisterLockInfo(lockName);
            }
        });
    }
    
    /**
     * 条件等待
     * @param lockName 锁名称
     * @param condition 条件
     * @param timeout 超时时间
     * @return 是否满足条件
     */
    public boolean waitForCondition(String lockName, Supplier<Boolean> condition, int timeout) {
        ReentrantLock lock = lockManager.getReentrantLock(lockName);
        Condition cond = lock.newCondition();
        
        try {
            if (lock.tryLock(timeout, TimeUnit.SECONDS)) {
                try {
                    return cond.awaitUntil(
                        LocalDateTime.now().plusSeconds(timeout),
                        condition
                    );
                } finally {
                    lock.unlock();
                }
            } else {
                return false;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    /**
     * 信号通知
     * @param lockName 锁名称
     */
    public void signalCondition(String lockName) {
        ReentrantLock lock = lockManager.getReentrantLock(lockName);
        Condition cond = lock.newCondition();
        
        try {
            if (lock.tryLock()) {
                try {
                    cond.signalAll();
                } finally {
                    lock.unlock();
                }
            }
        } catch (Exception e) {
            log.error("信号通知失败: lockName={}", lockName, e);
        }
    }
    
    /**
     * 读写分离
     * @param lockName 锁名称
     * @param readTask 读任务
     * @param writeTask 写任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeReadWriteSeparation(String lockName, Supplier<T> readTask, Supplier<T> writeTask) {
        // 优先尝试读锁
        try {
            return lockManager.executeWithReadLock(lockName, readTask);
        } catch (LockTimeoutException e) {
            // 读锁超时，使用写锁
            log.warn("读锁超时，使用写锁: {}", lockName);
            return lockManager.executeWithWriteLock(lockName, writeTask);
        }
    }
    
    /**
     * 分段锁
     * @param key 键
     * @param task 任务
     * @param <T> 返回类型
     * @return 执行结果
     */
    public <T> T executeWithSegmentLock(String key, Supplier<T> task) {
        int segment = Math.abs(key.hashCode()) % 16; // 16个分段
        String lockName = "segment_" + segment;
        
        return lockManager.executeWithReentrantLock(lockName, task);
    }
}

/**
 * Java锁控制器
 */
@RestController
@RequestMapping("/api/v1/java-lock")
public class JavaLockController {
    
    @Autowired
    private LockManager lockManager;
    
    @Autowired
    private LockOptimizationService lockOptimizationService;
    
    @Autowired
    private ConcurrencyControlService concurrencyControlService;
    
    /**
     * 使用可重入锁
     */
    @PostMapping("/reentrant")
    public ResponseEntity<Map<String, Object>> useReentrantLock(@RequestBody LockRequest request) {
        try {
            String result = lockManager.executeWithReentrantLock(request.getLockName(), () -> {
                // 模拟任务执行
                try {
                    Thread.sleep(request.getDelay());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return "任务执行完成: " + request.getTaskName();
            });
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("result", result);
            response.put("lockName", request.getLockName());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("使用可重入锁失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "使用可重入锁失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 使用读写锁
     */
    @PostMapping("/read-write")
    public ResponseEntity<Map<String, Object>> useReadWriteLock(@RequestBody ReadWriteLockRequest request) {
        try {
            String result;
            
            if ("read".equals(request.getLockType())) {
                result = lockManager.executeWithReadLock(request.getLockName(), () -> {
                    // 模拟读操作
                    try {
                        Thread.sleep(request.getDelay());
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "读操作完成: " + request.getTaskName();
                });
            } else {
                result = lockManager.executeWithWriteLock(request.getLockName(), () -> {
                    // 模拟写操作
                    try {
                        Thread.sleep(request.getDelay());
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "写操作完成: " + request.getTaskName();
                });
            }
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("result", result);
            response.put("lockName", request.getLockName());
            response.put("lockType", request.getLockType());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("使用读写锁失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "使用读写锁失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 使用戳锁
     */
    @PostMapping("/stamped")
    public ResponseEntity<Map<String, Object>> useStampedLock(@RequestBody StampedLockRequest request) {
        try {
            String result;
            
            if ("optimistic".equals(request.getLockType())) {
                result = lockManager.executeWithOptimisticRead(request.getLockName(), stamp -> {
                    // 模拟乐观读操作
                    try {
                        Thread.sleep(request.getDelay());
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "乐观读操作完成: " + request.getTaskName();
                });
            } else {
                result = lockManager.executeWithWriteLock(request.getLockName(), () -> {
                    // 模拟写操作
                    try {
                        Thread.sleep(request.getDelay());
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "写操作完成: " + request.getTaskName();
                });
            }
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("result", result);
            response.put("lockName", request.getLockName());
            response.put("lockType", request.getLockType());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("使用戳锁失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "使用戳锁失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 锁优化测试
     */
    @PostMapping("/optimization")
    public ResponseEntity<Map<String, Object>> testLockOptimization(@RequestBody LockOptimizationRequest request) {
        try {
            List<Supplier<String>> tasks = request.getTaskNames().stream()
                .map(taskName -> (Supplier<String>) () -> {
                    try {
                        Thread.sleep(request.getDelay());
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "任务执行完成: " + taskName;
                })
                .collect(Collectors.toList());
            
            List<String> results = lockOptimizationService.executeWithLockCoarsening(
                request.getLockName(), tasks);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("results", results);
            response.put("lockName", request.getLockName());
            response.put("taskCount", request.getTaskNames().size());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("锁优化测试失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "锁优化测试失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
}

/**
 * 锁请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LockRequest {
    private String lockName;
    private String taskName;
    private int delay; // 毫秒
}

/**
 * 读写锁请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ReadWriteLockRequest {
    private String lockName;
    private String taskName;
    private String lockType; // read, write
    private int delay; // 毫秒
}

/**
 * 戳锁请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class StampedLockRequest {
    private String lockName;
    private String taskName;
    private String lockType; // optimistic, write
    private int delay; // 毫秒
}

/**
 * 锁优化请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LockOptimizationRequest {
    private String lockName;
    private List<String> taskNames;
    private int delay; // 毫秒
}