C#线程执行超时处理与并发线程数控制实例

首先，我们需要明确一下本篇攻略的主要内容，即是如何应对C#程序中的线程执行超时问题以及控制并发线程数。接下来，我们将分几个方面来逐一介绍相关的方法和实例。

线程执行超时处理

在C#多线程编程中，一个常见的问题就是线程运行时间过长导致程序性能下降或死锁。为了解决这个问题，我们可以使用一个超时处理机制，即线程运行时间超过一定时间就强制终止线程，避免出现程序僵死的情况。

方式一：使用CancellationToken实现

使用CancellationToken最简单的方式就是通过传递一个token参数到Task.Run方法中，并在执行任务时定期地检查token是否被取消。一旦token被取消，任务将停止运行。

具体代码如下：

public static async Task<string> RunWithTimeoutAsync(int timeoutMilliseconds, 
    CancellationToken cancellationToken)
{
    using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
    {
        cts.CancelAfter(timeoutMilliseconds);
        try
        {
            await Task.Delay(Timeout.Infinite, cts.Token);
        }
        catch (OperationCanceledException)
        {
            return "Timeout!";
        }
    }
    return "Task completed successfully.";
}

方式二：使用Thread.Abort方法强制终止线程

Thread.Abort方法是.NET平台提供的强行终止线程的方法。我们可以在任务启动前创建一个Timer，并在超时后调用Thread.Abort方法强制终止线程。

注意：Thread.Abort方法非常不推荐使用，因为它可能会导致一些问题，例如无法释放资源，造成资源泄漏等。

具体代码如下：

static void Main(string[] args)
{
    Thread t = new Thread(ExecuteTask);
    t.Start();

    Timer timer = new Timer(new TimerCallback(delegate
    {
        t.Abort();
    }), null, timeoutInMilliseconds, Timeout.Infinite);

    Console.ReadKey();
}

public static void ExecuteTask()
{
    try
    {
        // 要执行的任务
    }
    catch (ThreadAbortException)
    {
        Thread.ResetAbort();
        // 可以做一些清理工作
    }
}

并发线程数控制

在某些场景下，我们需要控制程序中并发线程的数量，以避免过多的线程造成CPU和资源的浪费，同时也能提高程序的性能和稳定性。以下是两种不同的限制并发线程数的方法。

方式一：使用SemaphoreSlim实现

SemaphoreSlim是.NET平台提供的一个轻量级信号量机制。我们可以通过创建一个SemaphoreSlim对象限制最大并发线程数，每次请求线程锁时需要先获取一个信号量，使用完之后释放信号量。

具体代码如下：

static SemaphoreSlim locker = new SemaphoreSlim(4);

static void Main(string[] args)
{
    for (int i = 1; i <= 10; i++)
    {
        new Thread(() =>
        {
            locker.Wait();
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} started.");
            Thread.Sleep(5000); // 模拟耗时操作
            locker.Release();
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} end.");
        })
        { IsBackground = true }.Start();
    }
    Console.ReadKey();
}

该示例中SemaphoneSlim对象的初始值为4，表示最多只能有4个线程同时访问被锁定的代码块。通过调用Wait方法获取锁，执行完任务并通过Release方法释放锁。

方式二：使用ThreadPool实现

.NET平台提供的ThreadPool机制可以方便地进行并发线程数控制。我们可以通过调用ThreadPool.SetMaxThreads方法和ThreadPool.SetMinThreads方法设置最大和最小线程数，以控制并发线程数量。

示例代码如下：

static void Main(string[] args)
{
    ThreadPool.SetMaxThreads(4, 4);
    for (int i = 1; i <= 10; i++)
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
        {
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} started.");
            Thread.Sleep(5000); // 模拟耗时操作
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} end.");
        }));
    }
    Console.ReadKey();
}

该示例中，我们设置了最大和最小线程数为4，并启动了10个线程。由于最大并发数被限制为4，所以只有4个线程同时执行，其他线程需要等待空闲线程执行完毕后才能开始执行。

到这里，我们就完成了本次攻略中关于C#程序中线程超时处理和并发线程数控制的相关介绍和示例。希望对大家有所帮助。