C#多线程的相关操作讲解

在 C# 中，可以通过多线程机制来使一个程序同时执行多个任务，更好地利用计算资源，提高程序的效率和性能。本篇文章将针对 C# 多线程相关操作进行详细讲解，内容包括线程的创建、启动、停止，线程同步和互斥，以及线程池等多方面。

一、线程的创建和启动

C# 中可以使用 Thread 类来创建和启动线程。Thread 构造函数有两个重载形式：

public Thread(ThreadStart start);
public Thread(ParameterizedThreadStart start);

其中，ThreadStart 和 ParameterizedThreadStart 均为委托类型。ThreadStart 类型的委托不接受任何参数，用来创建一个不带参数的线程；ParameterizedThreadStart 类型的委托接受一个 object 类型的参数，用来创建一个带参数的线程。

以下是创建线程的示例代码：

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(DoWork));
        Thread t2 = new Thread(new ParameterizedThreadStart(DoWork));

        t1.Start();
        t2.Start("hello");
    }

    private static void DoWork()
    {
        Console.WriteLine("Thread executes DoWork without parameter.");
    }

    private static void DoWork(object param)
    {
        Console.WriteLine("Thread executes DoWork with parameter: {0}", (string)param);
    }
}

运行结果如下：

Thread executes DoWork without parameter.
Thread executes DoWork with parameter: hello

二、线程的停止

Thread 类提供了一些方法可以用来停止线程：

public void Abort();
public bool Join(int millisecondsTimeout); 
public bool Join(TimeSpan timeout);

其中，Abort() 方法可以用来终止线程的执行；Join() 方法可以让当前线程等待指定线程执行结束；Join() 方法还提供了可以设置等待时间的重载形式。需要注意的是，Abort() 方法可能会导致线程资源无法被垃圾回收器正确地释放，应当慎用。

以下是使用 Abort() 和 Join() 方法的示例代码：

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        Thread t = new Thread(new ThreadStart(DoWork));
        t.Start();

        Thread.Sleep(1000);  // 等待 1 秒钟

        t.Abort();

        if (!t.Join(TimeSpan.FromSeconds(1)))
        {
            Console.WriteLine("Thread still running after 1 second.");
        }
        else
        {
            Console.WriteLine("Thread finished in 1 second.");
        }
    }

    private static void DoWork()
    {
        try
        {
            while (true)
            {
                Console.WriteLine("Thread is running.");
                Thread.Sleep(100);
            }
        }
        catch (ThreadAbortException)
        {
            Console.WriteLine("Thread abort exception caught and handled.");
        }
    }
}

运行结果如下：

Thread is running.
Thread is running.
Thread is running.
Thread is running.
Thread is running.
Thread is running.
Thread is running.
Thread abort exception caught and handled.
Thread finished in 1 second.

三、线程的同步和互斥

多个线程同时访问共享资源时，很容易出现资源竞争和数据不一致等问题。C# 中提供了一些机制来解决这些问题。

1. lock 关键字

lock 关键字是一种简单的同步机制，可以确保一段代码只能被一个线程执行。lock 关键字使用示例如下：

using System;
using System.Threading;

public class Example
{
    private static readonly object lockObj = new object();
    private static int counter = 0;

    public static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(IncrementCounter));
        Thread t2 = new Thread(new ThreadStart(IncrementCounter));
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Final counter value: {0}", counter);
    }

    private static void IncrementCounter()
    {
        lock (lockObj)
        {
            for (int i = 0; i < 10000; i++)
            {
                counter++;
            }
        }
    }
}

运行结果如下：

Final counter value: 20000

需要注意的是，lock 关键字只能保证被锁定的代码块在同一时刻只有一个线程执行。如果有多个线程需要访问同一资源，但是访问的代码块互不重叠，就无法保证数据的一致性。

2. Monitor 类

Monitor 类提供了更加灵活和高级的同步机制。它提供了 Enter()、Exit()、TryEnter() 等方法，可以实现线程的互斥和同步等功能。下面是一个使用 Monitor 类的示例代码：

using System;
using System.Threading;

public class Example
{
    private static readonly object lockObj = new object();
    private static int counter = 0;

    public static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(IncrementCounter));
        Thread t2 = new Thread(new ThreadStart(IncrementCounter));
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Final counter value: {0}", counter);
    }

    private static void IncrementCounter()
    {
        bool lockTaken = false;
        try
        {
            Monitor.Enter(lockObj, ref lockTaken);
            for (int i = 0; i < 10000; i++)
            {
                counter++;
            }
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(lockObj);
            }
        }
    }
}

运行结果如下：

Final counter value: 20000

3. Interlocked 类

Interlocked 类提供了一些原子操作，可以保证多个线程对同一变量进行的操作是原子性的，从而保证线程安全。下面是一个使用 Interlocked 类的示例代码：

using System;
using System.Threading;

public class Example
{
    private static int counter = 0;

    public static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(IncrementCounter));
        Thread t2 = new Thread(new ThreadStart(IncrementCounter));
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Final counter value: {0}", counter);
    }

    private static void IncrementCounter()
    {
        for (int i = 0; i < 10000; i++)
        {
            Interlocked.Increment(ref counter);
        }
    }
}

运行结果如下：

Final counter value: 20000

需要注意的是，Interlocked 类只提供了一些简单的原子操作，无法解决复杂的同步问题。在实际编程中，应根据具体情况选择合适的同步机制。

四、线程池

线程池是 C# 提供的一种用于调度和维护线程的机制。线程池可以有效地重用线程，避免了频繁创建和销毁线程的开销，提高了程序的效率和性能。C# 中可以使用 ThreadPool 类来访问线程池的功能。

以下是使用线程池的示例代码：

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), "hello");

        Console.WriteLine("Main thread is running.");
        Thread.Sleep(1000);
    }

    private static void DoWork(object param)
    {
        Console.WriteLine("Thread pool thread executes DoWork with parameter: {0}.", (string)param);
        Thread.Sleep(500);
    }
}

运行结果如下：

Main thread is running.
Thread pool thread executes DoWork with parameter: hello.

需要注意的是，在使用线程池的时候，要尽量避免阻塞线程池线程，否则会导致线程池效率的下降。对于需要长时间运行的任务，应当创建新的线程来执行。

五、结论

C# 中的多线程机制可以帮助我们更好地利用计算资源，提高程序的效率和性能。在编写多线程程序的时候，要注意避免资源竞争和数据不一致等问题，选择合适的同步机制和线程池配置，才能保证程序的可靠性和性能。