引言
在 C# 開發(fā)中，合理控制并發(fā)任務數(shù)量是確保應用程序高效、穩(wěn)定運行的關鍵。過多的并發(fā)任務可能會耗盡系統(tǒng)資源，導致性能下降和不穩(wěn)定。本文將深入探討幾種有效的方法來限制 C# 中的并發(fā)任務數(shù)量，并通過具體的應用場景和示例代碼展示如何實現(xiàn)這些方法。
使用 SemaphoreSlim
SemaphoreSlim 是一個輕量級的同步原語，用于控制訪問某一資源或資源池的線程數(shù)。通過它，我們可以很容易地限制并發(fā)任務的數(shù)量。當你有一個需要訪問共享資源（如數(shù)據(jù)庫連接池）的任務列表，但希望同時執(zhí)行的任務數(shù)量不超過某個特定值時，可以使用SemaphoreSlim。
示例
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
int maxConcurrentTasks = 3;
SemaphoreSlim semaphore = new SemaphoreSlim(maxConcurrentTasks);
List<Task> tasks = new List<Task>();
for (int i = 0; i < 100; i++)
{
await semaphore.WaitAsync();
var task = Task.Run(async () =>
{
try
{
// 模擬長時間運行的任務
Console.WriteLine($"Task {Task.CurrentId} started.");
await Task.Delay(TimeSpan.FromSeconds(2));
Console.WriteLine($"Task {Task.CurrentId} completed.");
}
finally
{
semaphore.Release();
}
});
tasks.Add(task);
}
await Task.WhenAll(tasks);
Console.WriteLine("All tasks completed.");
}
}
在這個示例中，我們限制了最多只有 3 個任務可以同時運行。通過對SemaphoreSlim 的調(diào)用，我們確保了當達到最大并發(fā)任務數(shù)量時，其他任務將會等待直到某個任務完成并釋放信號量。
使用 TPL Dataflow
TPL (Task Parallel Library) Dataflow 提供了一個更高級的方式來處理數(shù)據(jù)流和并發(fā)任務，通過它可以很容易地限制并發(fā)任務的數(shù)量。當你需要處理一系列的數(shù)據(jù)或任務，并且每個任務都可能需要一些時間來完成，同時你想要限制同時處理這些任務的數(shù)量時，可以使用 TPL Dataflow。
示例
using System;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
class Program
{
static async Task Main(string[] args)
{
var options = new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 3 // 最大并發(fā)任務數(shù)量
};
var block = new ActionBlock<int>(async n =>
{
Console.WriteLine($"Processing {n}...");
await Task.Delay(TimeSpan.FromSeconds(1)); // 模擬異步操作
Console.WriteLine($"Processed {n}.");
}, options);
for (int i = 0; i < 100; i++)
{
block.Post(i);
}
block.Complete();
await block.Completion;
Console.WriteLine("All tasks completed.");
}
}
在這個示例中，ActionBlock 被用來處理一系列的任務，通過設置ExecutionDataflowBlockOptions 中的MaxDegreeOfParallelism 屬性，我們限制了最大的并發(fā)任務數(shù)量。
使用 Parallel.ForEach
Parallel.ForEach 是 .NET 中用于并行處理集合元素的方法，它可以指定MaxDegreeOfParallelism 參數(shù)來限制并發(fā)任務的數(shù)量。
示例
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var urls = new List<string> { /* 一系列 URL */ };
var options = new ParallelOptions { MaxDegreeOfParallelism = 3 };
await Parallel.ForEachAsync(urls, options, async (url, _) =>
{
var html = await new HttpClient().GetStringAsync(url);
Console.WriteLine($"retrieved {html.Length} characters from {url}");
});
}
}
在這個示例中，我們使用Parallel.ForEachAsync 方法來并行下載多個網(wǎng)頁內(nèi)容，并通過設置MaxDegreeOfParallelism 為 3 來限制同時進行的下載任務數(shù)量。
使用 Polly Bulkhead
Polly 是一個強大的 .NET 錯誤處理和彈性庫，它的 Bulkhead 隔板策略可以限制并發(fā)任務的數(shù)量，并可以選擇將超過該數(shù)量的任務排隊。
示例
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Polly;
class Program
{
static async Task Main(string[] args)
{
var bulkhead = Policy.BulkheadAsync(3, Int32.MaxValue); // 最大并發(fā)任務數(shù)量為 3
var urls = new List<string> { /* 一系列 URL */ };
var tasks = new List<Task>();
foreach (var url in urls)
{
var t = bulkhead.ExecuteAsync(async () =>
{
var html = await new HttpClient().GetStringAsync(url);
Console.WriteLine($"retrieved {html.Length} characters from {url}");
});
tasks.Add(t);
}
await Task.WhenAll(tasks);
}
}
在這個示例中，我們使用 Polly 的 Bulkhead 隔板策略來限制并發(fā)下載任務的數(shù)量，并將超過最大并發(fā)數(shù)量的任務自動排隊。
使用 Task.WhenAny
Task.WhenAny 方法可以用于限制并發(fā)任務的數(shù)量，其基本思路是維護一個任務列表，當任務數(shù)量達到閾值時，等待其中一個任務完成，然后繼續(xù)添加新任務。
示例
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var urls = new List<string> { /* 一系列 URL */ };
var maxConcurrentTasks = 3;
var tasks = new List<Task>();
foreach (var url in urls)
{
tasks.Add(Task.Run(async () =>
{
var html = await new HttpClient().GetStringAsync(url);
Console.WriteLine($"retrieved {html.Length} characters from {url}");
}));
if (tasks.Count >= maxConcurrentTasks)
{
await Task.WhenAny(tasks);
tasks = tasks.Where(t => t.Status == TaskStatus.Running).ToList();
}
}
await Task.WhenAll(tasks);
}
}
在這個示例中，我們通過Task.WhenAny 方法來等待任務列表中的任意一個任務完成，然后移除已完成的任務，從而保持并發(fā)任務的數(shù)量不超過閾值。
總結
限制并發(fā)任務的數(shù)量是確保應用程序穩(wěn)定和高效運行的關鍵。在 C# 中，我們可以使用SemaphoreSlim、TPL Dataflow、Parallel.ForEach、Polly Bulkhead 和Task.WhenAny 等多種方法來輕松實現(xiàn)這一目標。根據(jù)具體的業(yè)務需求和應用場景，選擇最合適的方法來控制并發(fā)任務的數(shù)量，可以有效避免資源過度消耗，提高系統(tǒng)的響應速度和可靠性。
該文章在 2024/12/24 11:48:49 編輯過
400 186 1886
