c# - 具有动态 maxCount 的 SemaphoreSlim

Question

我遇到了一个问题，我需要限制对另一个网络服务器的调用次数。它会有所不同，因为服务器是共享的，并且可能具有更多或更少的容量。

我正在考虑使用 SemaphoreSlim 类，但没有公共(public)属性可以更改最大计数。

我应该将我的 SemaphoreSlim 类包装在另一个处理最大计数的类中吗？有没有更好的方法？

编辑:

这是我正在尝试的:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Semaphore
{
class Program
{
    static SemaphoreSlim _sem = new SemaphoreSlim(10,10000);

    static void Main(string[] args)
    {
        int max = 15;

        for (int i = 1; i <= 50; i++)
        {
            new Thread(Enter).Start(new int[] { i, max});
        }

        Console.ReadLine();

        max = 11;

        for (int i = 1; i <= 50; i++)
        {
            new Thread(Enter).Start(new int[] { i, max });
        }
    }

    static void Enter(object param)
    {
        int[] arr = (int[])param;
        int id = arr[0];
        int max = arr[1];

        try
        {
            Console.WriteLine(_sem.CurrentCount);

            if (_sem.CurrentCount <= max)
                _sem.Release(1);
            else
            {
                _sem.Wait(1000);

                Console.WriteLine(id + " wants to enter");

                Thread.Sleep((1000 * id) / 2); // can be here at

                Console.WriteLine(id + " is in!"); // Only three threads

            }
        }
        catch(Exception ex)
        {
            Console.WriteLine("opps ", id);
            Console.WriteLine(ex.Message);
        }
        finally            
        {
            _sem.Release();
        }
    }
}
}

问题:

1-_sem.Wait(1000) 应该取消将执行超过 1000 毫秒的线程的执行，不是吗？

2-我有没有使用 Release/Wait 的想法？

Answer 1

您不能更改最大计数，但您可以创建一个具有非常高的最大计数的 SemaphoreSlim，并保留其中的一些。参见 this constructor .

假设并发调用的绝对最大值为 100，但最初您希望它为 25。您初始化信号量:

SemaphoreSlim sem = new SemaphoreSlim(25, 100);

所以 25 是可以并发服务的请求数。您已保留其他 75 个。

如果您想增加允许的数量，只需调用 Release(num) .如果您调用 Release(10)，则数字将变为 35。

现在，如果您想减少可用请求的数量，您必须多次调用 WaitOne。例如，如果您想从可用计数中删除 10:

for (var i = 0; i < 10; ++i)
{
    sem.WaitOne();
}

这有可能会阻塞，直到其他客户端释放信号量。也就是说，如果您允许 35 个并发请求并希望将其减少到 25，但已经有 35 个客户端有事件请求，则 WaitOne 将阻塞，直到客户端调用 Release，直到释放 10 个客户端，循环才会终止。