服务接收并发异步请求后，如何确保ImportFile方法调用串行执行？

嘿，这个场景我太熟了！咱们先把你那个仓库的例子补完整：一堆工人（多线程）同时接收到客户寄来的包裹（并发请求），卸货、搬到仓库门口（对应UploadAndImport里的上传逻辑）这些活儿可以同时干，但要把包裹登记入库（就是你的ImportFile(...)）的时候，必须一个来完再下一个——不然仓库台账直接乱套，谁知道哪个包裹先入库对吧？

下面给你分语言讲具体实现，都是生产环境能用的方案：

核心逻辑：给串行操作加「唯一准入锁」 #

说白了就是给ImportFile(...)这个必须排队的操作配一把“唯一钥匙”，谁拿到钥匙谁才能去执行，其他人只能在旁边等着，等钥匙交回来再轮到下一个。

C# 实现示例 #

如果你的ImportFile是同步方法，用最简单的lock就行：

// 重点：这个锁对象必须是静态的！确保所有线程共用同一把锁
private static readonly object _importLock = new object();

public async Task UploadAndImport(string filePath)
{
    // 这部分是可以并发执行的上传逻辑，比如把文件传到服务器
    await UploadFileToServer(filePath);

    // 关键：用lock把ImportFile包起来，强制串行
    lock (_importLock)
    {
        // 现在这个方法绝对是一个接一个执行的，不会乱
        ImportFile(filePath);
    }
}

如果ImportFile是异步方法，别用普通lock（会阻塞线程池），用SemaphoreSlim更合适：

private static readonly SemaphoreSlim _importSemaphore = new SemaphoreSlim(1, 1);

public async Task UploadAndImport(string filePath)
{
    await UploadFileToServer(filePath);

    // 申请准入资格，没有就等着
    await _importSemaphore.WaitAsync();
    try
    {
        // 异步串行执行核心操作
        await ImportFileAsync(filePath);
    }
    finally
    {
        // 必须释放资格，不然其他人永远等不到
        _importSemaphore.Release();
    }
}

Java 实现示例 #

同步场景用synchronized关键字就行：

// 全局唯一锁对象，static确保所有实例共用
private static final Object importLock = new Object();

public void uploadAndImport(String filePath) {
    // 并发执行的上传逻辑
    uploadFileToServer(filePath);

    // 串行执行入库登记
    synchronized (importLock) {
        importFile(filePath);
    }
}

异步场景用Semaphore或者ReentrantLock，这里给你看Semaphore的写法：

private static final Semaphore importSemaphore = new Semaphore(1);

public CompletableFuture<Void> uploadAndImport(String filePath) {
    // 先异步处理上传
    return CompletableFuture.runAsync(this::uploadFileToServer)
            // 上传完后申请锁串行执行入库
            .thenRun(() -> {
                try {
                    importSemaphore.acquire();
                    importFile(filePath);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    // 务必释放锁，避免死锁
                    importSemaphore.release();
                }
            });
}

对应仓库场景的直白解释 #

• 多线程工人：处理UploadAndImport请求的多个并发线程
• 客户包裹：每个UploadAndImport调用请求
• 搬包裹到仓库门口：UploadFileToServer，可以并发做，不影响核心数据
• 入库登记：ImportFile，必须串行，锁就像登记台的唯一号，只有拿到号的工人才能登记，其他人排队

避坑提醒 #

• 锁对象必须全局唯一，如果每个线程都新建一个锁，那等于没锁，大家还是会同时抢
• 异步场景别用同步锁（比如C#的lock、Java的synchronized），会浪费线程池资源
• 一定要在finally块里释放锁/信号量，哪怕方法抛出异常也得放，不然会导致死锁，后续请求永远处理不了

内容的提问来源于stack exchange，提问作者Shaun Luttin