C#のスレッドプールを完全に管理する方法 – 効率的なリソース活用とパフォーマンス向上

ThreadPool.SetMaxThreads(workerThreads: 20, completionPortThreads: 10);

ThreadPool.SetMinThreads(workerThreads: 10, completionPortThreads: 5);

ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
ThreadPool.GetMinThreads(out int minWorkerThreads, out int minCompletionPortThreads);

ThreadPool.QueueUserWorkItem(state =>
{
    // タスクの内容
    Console.WriteLine("タスクが実行されています。");
});

var cts = new CancellationTokenSource();
ThreadPool.QueueUserWorkItem(state =>
{
    var token = (CancellationToken)state;
    // タスクの内容
    while (!token.IsCancellationRequested)
    {
        Console.WriteLine("タスクが実行されています。");
        Thread.Sleep(1000);
    }
}, cts.Token);

var highPriorityQueue = new ConcurrentQueue<Action>();
var normalPriorityQueue = new ConcurrentQueue<Action>();

void ProcessTasks()
{
    while (true)
    {
        if (highPriorityQueue.TryDequeue(out var highPriorityTask))
        {
            highPriorityTask();
        }
        else if (normalPriorityQueue.TryDequeue(out var normalPriorityTask))
        {
            normalPriorityTask();
        }
        Thread.Sleep(100); // CPU負荷を軽減するためのスリープ
    }
}

ThreadPool.QueueUserWorkItem(state => ProcessTasks());

ThreadPool.GetAvailableThreads(out int workerThreads, out int completionPortThreads);
Console.WriteLine($"利用可能なワーカースレッド: {workerThreads}");
Console.WriteLine($"利用可能なI/Oコンプレッションポートスレッド: {completionPortThreads}");

var logger = new LoggerFactory().CreateLogger("ThreadPoolMonitor");
ThreadPool.QueueUserWorkItem(state =>
{
    while (true)
    {
        ThreadPool.GetAvailableThreads(out int workerThreads, out int completionPortThreads);
        logger.LogInformation($"利用可能なワーカースレッド: {workerThreads}, I/Oコンプレッションポートスレッド: {completionPortThreads}");
        Thread.Sleep(5000); // 5秒ごとにログを記録
    }
});

ThreadPool.SetMaxThreads(workerThreads: 50, completionPortThreads: 20);
ThreadPool.SetMinThreads(workerThreads: 10, completionPortThreads: 5);

for (int i = 0; i < 1000; i++)
{
    ThreadPool.QueueUserWorkItem(state =>
    {
        // 適切なサイズのタスク内容
        PerformTask(i);
    });
}

object lockObject = new object();
ThreadPool.QueueUserWorkItem(state =>
{
    lock (lockObject)
    {
        // 同期が必要な処理
        PerformSynchronizedTask();
    }
});

async Task PerformAsyncTask()
{
    await Task.Run(() =>
    {
        // 非同期に実行されるタスクの内容
        PerformLongRunningTask();
    });
}

string[] files = Directory.GetFiles("C:\\Data");
foreach (string file in files)
{
    ThreadPool.QueueUserWorkItem(state =>
    {
        ProcessFile(file);
    });
}

void ProcessFile(string filePath)
{
    // ファイルの処理内容
    Console.WriteLine($"Processing {filePath}");
    // ファイルの読み込みや書き込みなどの処理
}

string[] urls = { "http://example.com/page1", "http://example.com/page2", "http://example.com/page3" };
foreach (string url in urls)
{
    ThreadPool.QueueUserWorkItem(state =>
    {
        ScrapeWebPage(url);
    });
}

void ScrapeWebPage(string url)
{
    using (HttpClient client = new HttpClient())
    {
        string content = client.GetStringAsync(url).Result;
        Console.WriteLine($"Scraped {url}");
        // スクレイピングしたデータの処理
    }
}

List<Task> tasks = new List<Task>();
for (int i = 0; i < 10; i++)
{
    int taskId = i;
    tasks.Add(Task.Run(() =>
    {
        PerformLongRunningTask(taskId);
    }));
}

await Task.WhenAll(tasks);

void PerformLongRunningTask(int id)
{
    // 長時間実行されるタスクの内容
    Console.WriteLine($"Task {id} started.");
    Thread.Sleep(5000); // 例: 5秒間の処理
    Console.WriteLine($"Task {id} completed.");
}

object lock1 = new object();
object lock2 = new object();

void SafeMethod()
{
    lock (lock1)
    {
        lock (lock2)
        {
            // ロックされたリソースへのアクセス
        }
    }
}

class ResourceHandler : IDisposable
{
    public void Dispose()
    {
        // リソースの解放
    }
}

ThreadPool.QueueUserWorkItem(state =>
{
    using (ResourceHandler handler = new ResourceHandler())
    {
        // リソースを使用するタスク
    }
});

ThreadPool.SetMaxThreads(workerThreads: 100, completionPortThreads: 50);

ThreadPool.QueueUserWorkItem(state =>
{
    try
    {
        // タスクの実行内容
    }
    catch (Exception ex)
    {
        // 例外の処理
        Console.WriteLine($"Error: {ex.Message}");
    }
});

List<string> data = GetData();
ConcurrentBag<AnalysisResult> results = new ConcurrentBag<AnalysisResult>();

foreach (var item in data)
{
    ThreadPool.QueueUserWorkItem(state =>
    {
        var result = AnalyzeData(item);
        results.Add(result);
    });
}

void AnalyzeData(string item)
{
    // データ分析のロジック
    return new AnalysisResult { Item = item, Value = ComputeValue(item) };
}

void HandleRequest(HttpListenerContext context)
{
    ThreadPool.QueueUserWorkItem(state =>
    {
        var response = ProcessRequest(context.Request);
        context.Response.ContentType = "text/plain";
        using (var writer = new StreamWriter(context.Response.OutputStream))
        {
            writer.Write(response);
        }
        context.Response.Close();
    });
}

string ProcessRequest(HttpListenerRequest request)
{
    // リクエスト処理のロジック
    return "Request processed successfully.";
}