如何优雅高效地实现两个HttpClient的50%请求分配，避免锁阻塞并保障吞吐量？

问题背景 #

你目前有一个SomeValueController，需要将50%的请求分配给MainClient，另外50%分配给BackupClient。当前通过ClientProvider加锁切换布尔值的方式实现，但锁会导致请求阻塞，影响高并发场景下的性能：

控制器代码：

[Route("some-value")]
[ApiController]
public class SomeValueController : ControllerBase
{
    private readonly ClientProvider _clientProvider;

    public SomeValueController(ClientProvider clientProvider)
    {
        _clientProvider = clientProvider;
    }

    [HttpGet]
    public async Task<ActionResult> Index([FromQuery] string from, [FromQuery] string to)
    {
        var values = await _clientProvider.GetClient().GetValues(from, to);
        return Ok(values);
    }
}

当前ClientProvider实现：

public class ClientProvider
{
    private readonly MainClient _mainClient;
    private readonly BackupClient _backupClient;
    private readonly ILogger<ClientProvider> _logger;
    private bool _flag = false;
    private object _lock = new Object();

    public ClientProvider(BackupClient backupClient, MainClient mainClient, ILogger<ClientProvider> logger)
    {
        _backupClient = backupClient;
        _mainClient = mainClient;
        _logger = logger;
    }

    public IExchangeClient GetClient()
    {
        lock (_lock)
        {
            var client = _flag ? _backupClient as IExchangeClient : _mainClient;
            _flag = !_flag;
            return client;
        }
    }
}

你希望找到无锁、高效的替代方案，避免锁带来的阻塞问题。

解决方案1：使用Interlocked原子操作切换布尔值 #

Interlocked类提供了硬件级别的原子操作，不需要显式加锁就能保证线程安全，性能比锁高很多。我们可以用Interlocked.Exchange来原子性地切换标记值：

public class ClientProvider
{
    private readonly MainClient _mainClient;
    private readonly BackupClient _backupClient;
    private readonly ILogger<ClientProvider> _logger;
    private int _flag = 0; // 用int代替bool，适配Interlocked操作

    public ClientProvider(BackupClient backupClient, MainClient mainClient, ILogger<ClientProvider> logger)
    {
        _backupClient = backupClient;
        _mainClient = mainClient;
        _logger = logger;
    }

    public IExchangeClient GetClient()
    {
        // 原子性翻转标记：0变1，1变0，同时返回旧值
        var currentFlag = Interlocked.Exchange(ref _flag, _flag == 0 ? 1 : 0);
        
        return currentFlag == 0 ? _mainClient : (_backupClient as IExchangeClient);
    }
}

原理说明 #

• Interlocked.Exchange是不可分割的原子操作，不会出现多线程同时修改标记的问题，完全替代了锁的作用。
• 用int代替bool是因为Interlocked对整数类型的原子操作更直接，避免了额外的类型转换开销。

解决方案2：基于原子计数器的轮询分配 #

如果想要更均匀的请求分配（尤其是高并发场景下），可以用一个原子递增的计数器，通过取模操作选择客户端：

public class ClientProvider
{
    private readonly MainClient _mainClient;
    private readonly BackupClient _backupClient;
    private readonly ILogger<ClientProvider> _logger;
    private long _requestCounter = 0;

    public ClientProvider(BackupClient backupClient, MainClient mainClient, ILogger<ClientProvider> logger)
    {
        _backupClient = backupClient;
        _mainClient = mainClient;
        _logger = logger;
    }

    public IExchangeClient GetClient()
    {
        // 原子性递增计数器，返回递增后的数值
        var currentCount = Interlocked.Increment(ref _requestCounter);
        
        // 偶数请求用MainClient，奇数请求用BackupClient
        return currentCount % 2 == 0 ? _mainClient : (_backupClient as IExchangeClient);
    }
}

优势 #

• 这种方式的分配比布尔翻转更稳定，大量并发请求瞬间到达时，不会出现短暂的分配倾斜。
• 如果未来需要扩展到更多客户端（比如3个），只需要修改取模的数值即可，扩展性更强。

方案对比 #

两种方案都完全避免了锁的使用，不会造成线程阻塞，能显著提升高并发下的性能。

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