【Java】记录单服务器中根据key决定并发访问

现在有一个需求：在单服务器中，有一个业务方法需要根据客服端传过来的参数订单ID来决定处理方式。如果订单ID相同，则并发访问这个业务方法；如果订单ID不相同，则可以并行访问这个业务方法。
下面是自己认为的解决方案：

1、定义同步处理类

@Component
public class SynchronizedByKey {
    // 缓存锁
    private final ConcurrentHashMap<String, ReentrantLock> keyToReentrantLockMap = new ConcurrentHashMap<>();

    /**
     * 判断key的值是否相同，相同则并发执行任务，不相同则并行执行任务。
     * [1] 必须要保证线程拿着的锁与缓存中的锁是同一个锁，才允许执行任务
     * @param key   键值
     * @param statement 任务
     */
    public void exec(String key, Runnable statement){
        // 线程拿着的锁
        ReentrantLock lock = null;
        // 缓存中的锁
        ReentrantLock lockInCache;
        do {
            if (lock != null){
                lock.unlock();
            }
            lock = keyToReentrantLockMap.computeIfAbsent(key, k -> new ReentrantLock());
            lock.lock();
            lockInCache = keyToReentrantLockMap.get(key);
        }while (lock != lockInCache);  // [1] 如果缓存中的锁为null 或者 缓存中的锁不等于线程拿着的锁，则重新去获取锁
        try {
            // 执行任务
            statement.run();
        } finally {
            // 如果线程拿着的锁的等待数为0，则移除缓存中的锁，避免OOM。（这里只是大致估计，不一定真的为0时才执行）
            if (lock.getQueueLength() == 0) {
                keyToReentrantLockMap.remove(key);
            }
            lock.unlock();
        }
    }
}

2、定义一个测试类

@Controller
@RequestMapping("/lock")
@AllArgsConstructor
public class LockController {

    private final SynchronizedByKey synchronizedByKey;

    @GetMapping("/{orderId}")
    public void test(@PathVariable("orderId") String orderId){
        // 模拟一个高并发50000次相同的请求
        MyRunnable statement = new MyRunnable();
        for (int i = 0; i < 50000; i++) {
            new Thread(() -> {
                synchronizedByKey.exec(orderId, statement);
            }).start();
        }
    }

    /**
     * 业务
     */
    public static class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("开始");
            System.out.println("结束");
        }
    }

}

浏览器访问对应的接口http://localhost:8081/myspringboot001/lock/001后，运行结果如下：

在输出日志中可以看到确实实现了这个需求。

当然，也可以使用字符串常量池（orderId.intern()）作为同步锁的方式，但是不太建议这样子做。