处理多线程 C#

在C#中，多线程是一个非常常见的需求。但是，如果不能正确处理多线程，就有可能会导致各种奇怪的问题。本文将介绍如何在C#中处理多线程。

Task

.NET中内置有一个 Task 类，可以方便地管理多个线程。可以使用 Task.Factory.StartNew 方法来创建一个新的线程，如下所示：

Task.Factory.StartNew(() =>
{
    // Do some work here.
});

可以使用 ContinueWith 方法来在一个任务完成后执行另一个任务，如下所示：

Task.Factory.StartNew(() =>
{
    // Do some work here.
})
.ContinueWith((previousTask) =>
{
    // Do some more work here.
});

可以使用 Task.WaitAll 方法来等待多个任务完成，如下所示：

Task[] tasks = new Task[3];

for (int i = 0; i < 3; i++)
{
    int index = i;
    tasks[i] = Task.Factory.StartNew(() =>
    {
        // Do some work here.
    });
}

Task.WaitAll(tasks);

线程锁

当多个线程同时访问一个共享资源时，就可能会出现问题。例如，如果两个线程同时尝试写入一个文件，就可能会导致数据的损坏。为了避免这种情况，需要使用线程锁。

可以使用 lock 关键字来创建一个线程锁，如下所示：

private object lockObject = new object();

public void WriteToFile(string fileName, string content)
{
    lock (lockObject)
    {
        // Write to the file here.
    }
}

在上面的代码中，变量 lockObject 是一个锁对象。在 WriteToFile 方法中，通过使用 lock 关键字来锁定这个锁对象，确保多个线程不能同时进入这个方法。

可重入锁

有时候，同一个线程可能需要多次进入一个被锁定的方法。例如，在递归方法中，同一个线程可能会多次进入同一个方法。这时候就需要使用可重入锁。

可以使用 Monitor.Enter 和 Monitor.Exit 方法来创建可重入锁，如下所示：

private object lockObject = new object();
private int recursionCounter = 0;

public void RecursiveMethod()
{
    bool lockTaken = false;

    try
    {
        Monitor.Enter(lockObject, ref lockTaken);

        recursionCounter++;

        // Do some work here.

        RecursiveMethod();
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(lockObject);
        }
    }
}

在上面的代码中，变量 lockObject 是一个锁对象。在 RecursiveMethod 方法中，通过使用 Monitor.Enter 方法来锁定这个锁对象，确保多个线程不能同时进入这个方法。由于这里使用了 ref 关键字，lockTaken 变量表示是否已经锁定，避免了对同一个锁对象进行多次加锁。

线程池

当需要同时运行多个线程时，可以使用线程池来管理这些线程。线程池可以避免频繁地创建和销毁线程，提高性能。

可以使用 ThreadPool.QueueUserWorkItem 方法来将工作项添加到线程池中，如下所示：

ThreadPool.QueueUserWorkItem((state) =>
{
    // Do some work here.
});

取消任务

有时候，需要取消正在执行的任务。可以使用 CancellationToken 对象来实现任务的取消。

可以使用 Task.Run 方法来创建一个任务，并传入一个 CancellationToken 对象，如下所示：

CancellationTokenSource cts = new CancellationTokenSource();

Task.Run(() =>
{
    while (true)
    {
        // Do some work here.

        if (cts.Token.IsCancellationRequested)
        {
            break;
        }
    }
}, cts.Token);

在上面的代码中，变量 cts 是一个 CancellationTokenSource 对象。在任务中，如果需要取消任务，可以调用 cts.Cancel 方法。在任务中，可以使用 cts.Token.IsCancellationRequested 属性来判断是否已经请求取消。

结论

在C#中处理多线程并不是一件容易的事情，但是通过使用 Task、线程锁、可重入锁、线程池和取消任务等技术，可以解决各种问题，并提高应用程序的性能。