C#多线程环境下实现无返回值函数的排队串行调用

该需求完全可以实现，C# 框架本身提供了多种成熟的同步原语和实现方式，以下是不同场景下的常用方案：

方案1：使用lock关键字（适合同步方法、简单场景） #

lock是C#内置的轻量级互斥锁，是最简单的串行执行实现方式，同一时间仅会有一个线程进入锁包裹的代码块，其余线程会在外排队等待前一个线程执行完成。

// 声明唯一的私有锁对象，禁止使用this、字符串等公开或可复用的对象作为锁
private static readonly object _lockObj = new object();

public void YourTargetFunction()
{
    lock (_lockObj)
    {
        // 此处放置你的原有函数逻辑
    }
}

方案2：使用SemaphoreSlim（适合异步方法、需要灵活控制的场景） #

lock不支持异步场景（await后线程切换会导致锁释放异常），异步逻辑可以使用SemaphoreSlim实现并行数控制，将最大并行数设为1即可满足串行执行要求，同时支持超时、取消令牌等扩展能力。

// 初始化信号量，初始许可数、最大许可数均设为1
private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

public async Task YourAsyncTargetFunction(CancellationToken cancellationToken = default)
{
    // 等待获取信号量，可传入取消令牌、超时时间做额外控制
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        // 此处放置你的原有异步函数逻辑
        await SomeAsyncOperation(cancellationToken);
    }
    finally
    {
        // 必须在finally中释放信号量，避免异常后卡住后续所有请求
        _semaphore.Release();
    }
}

方案3：队列+后台Worker模式（适合非阻塞调用、高吞吐场景） #

如果不希望调用线程被阻塞等待执行，可以用队列存储所有调用请求，后台单独启动Worker线程按顺序消费执行，完全隔离调用方和执行逻辑，适合调用量高、需要削峰的场景。

// 初始化无界通道，用于存储调用请求
private static readonly Channel<Action> _requestChannel = Channel.CreateUnbounded<Action>();

// 静态构造函数中启动后台处理线程
static YourClass()
{
    _ = ProcessRequestsAsync();
}

// 对外暴露的调用入口，调用方写入请求后立即返回，不会被阻塞
public void EnqueueFunctionCall(Action functionLogic)
{
    _requestChannel.Writer.TryWrite(functionLogic);
}

// 后台循环处理请求，天然保证串行执行
private static async Task ProcessRequestsAsync()
{
    await foreach (var func in _requestChannel.Reader.ReadAllAsync())
    {
        try
        {
            func.Invoke();
        }
        catch (Exception ex)
        {
            // 自定义处理执行异常
        }
    }
}

选型建议 #

• 若目标函数为同步逻辑、调用量不大：优先选lock，实现最简单、性能开销极低
• 若目标函数为异步逻辑、需要支持超时/取消等控制：选SemaphoreSlim
• 若不希望调用线程被阻塞、需要做流量削峰：选队列+后台Worker模式

注意事项 #

• 无论使用哪种方案，都要保证异常场景下锁/信号量能被正确释放，避免所有后续请求被永久阻塞
• 尽量不要在串行执行的逻辑内部嵌套其他加锁逻辑，避免触发死锁
• 如果函数调用频率极高，串行执行会成为性能瓶颈，可优先优化目标函数本身的线程安全性，实现并行执行

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