Question

我正在尝试建立一个稳定的多线程系统（使用设置的确切线程数）

这是我实际使用的代码：

Select a.id from
Authors a
join posts b on a.id=b.author_id
join comments c on 
c.post_id=b.id
Where c.type='good';

这是快速且有效的，但是它超过了100个线程限制，如果我使用的代理服务器锁定了100个同时连接，这将不是问题，因此，我的代理提供商会取消很多请求，无论如何如何保持线程速度不超过限制？

谢谢。

Answer 1

您的Framwork.Send方法立即返回并异步处理。为了验证这一点，我创建了以下测试方法，该方法可以按预期工作：

public static void Main()
{
    List<String> list = new List<String>(Enumerable.Range(0,10000).Select(i=>i.ToString()));

    int maxThreads = 100;

    ThreadPool.SetMinThreads(maxThreads, maxThreads);

    int currentCount = 0;
    int maxCount = 0;
    object locker = new object();
    Parallel.ForEach(list, new ParallelOptions { MaxDegreeOfParallelism = maxThreads }, delegate (string url)
    {
        lock (locker)
        {
            currentCount++;
            maxCount = Math.Max(currentCount, maxCount);
        }
        Thread.Sleep(10);
        lock (locker)
        {
            maxCount = Math.Max(currentCount, maxCount);
            currentCount--;
        }
    });

    Console.WriteLine("Max Threads: " + maxCount); //Max Threads: 100
    Console.Read();
}

Answer 2

Parallel.For/Foreach用于数据并行化-处理大量不需要执行IO的数据。在这种情况下，没有理由使用比可以运行它们的核心更多的线程。

这个问题与网络IO，并发连接和限制有关。如果代理提供者有限制，则必须将MaxDegreeOfParallelism设置为足够低的值，以免超出限制。

一个更好的解决方案是使用一个ActionBlock，其MaxDegreeOfParallelism受到限制，并限制其输入缓冲区，这样它就不会被等待处理的URL淹没。

static async Task Main()
{
    var maxConnections=20;
    var options=new ExecutionDataflowBlockOptions 
                {
                    MaxDegreeOfParallelism = maxConnections,
                    BoundedCapacity        = maxConnections * 2
                };
    var framework = new Sender();
    var myBlock=new ActionBlock<string>(url=>
                {
                    framework.Send(...);
                }, options);

    //ReadLines doesn't load everything, it returns an IEnumerable<string> that loads
    //lines as needed
    var lines = File.ReadLines("urls.txt");

    foreach(var url in lines)
    {
        //Send each line to the block, waiting if the buffer is full
        await myBlock.SendAsync(url);
    }
    //Tell the block we are done
    myBlock.Complete();
    //And wait until it finishes everything
    await myBlock.Completion;
}

设置限制容量和MaxDegreeOfParallelism有助于并发限制，但不适用于请求/秒限制。为了限制这一点，可以在每个请求之后添加一小段延迟。该块的代码必须更改为例如：

    var delay=250; // Milliseconds, 4 reqs/sec per connection
    var myBlock=new ActionBlock<string>( async url=>
                {
                    framework.Send(...);
                    await Task.Delay(delay);
                }, options);

如果Sender.Send成为异步方法，则可以进一步改进。例如，它可以使用仅提供异步方法的HttpClient，因此它不会阻止等待响应。更改将是最小的：

    var myBlock=new ActionBlock<string>( async url=>
                {
                    await framework.SendAsync(...);
                    await Task.Delay(delay);
                }, options);

但是该程序将使用 less 个线程和更少的CPU-对await ...的每次调用都会释放当前线程，直到收到响应为止。

另一方面，阻塞线程需要一次spinwait，这意味着在线程进入睡眠之前浪费CPU等待响应的周期。

Parallel.ForEach超过线程数限制

2 个答案: