C#多线程及同步示例简析

在C#中，多线程编程可以提高CPU利用率，提高程序的响应速度，增强程序的稳定性。但多线程编程中也会遇到诸多问题，比如线程安全、死锁、优先级等问题，需要进行同步和协同操作。本文将从多线程编程和同步操作两个方面进行简要分析，并提供两个实例来加深读者的理解。

多线程编程示例

示例一：简单的启动线程和等待线程结束

using System;
using System.Threading;

class Program
{
    static void Main(string[] args)
    {
        Thread thread = new Thread(Worker);
        thread.Start();
        Console.WriteLine("主线程开始等待工作线程结束");
        thread.Join();
        Console.WriteLine("工作线程已结束");
    }

    static void Worker()
    {
        Console.WriteLine("工作线程正在工作...");
        Thread.Sleep(5000); // 模拟一些工作
        Console.WriteLine("工作线程已结束");
    }
}

上述示例中，通过创建Worker方法的线程，来模拟一些耗时的工作，而主线程则在启动此线程之后，等待线程结束，再继续执行代码。

示例二：线程安全的计数器

using System;
using System.Threading;

class Program
{
    static volatile int count = 0; // volatile确保写操作的可见性

    static void Main(string[] args)
    {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(Worker);
            threads[i].Start();
        }
        foreach (Thread thread in threads) thread.Join(); // 等待所有线程结束
        Console.WriteLine("计数器结果: " + count);
    }

    static void Worker()
    {
        for (int i = 0; i < 100000; i++) Interlocked.Increment(ref count); // 加锁保证访问安全
    }
}

上述示例中，创建10个线程，每个线程都会执行100000次的计数操作。由于多个线程可能会同时对计数器进行修改，会导致数据不一致或者程序崩溃等问题。因此，在每次修改计数器时，需要使用加锁保证访问的安全性。同时使用volatile关键字，确保写操作的可见性。

同步示例

示例一：互斥锁

using System;
using System.Threading;

class Program
{
    static bool stop = false;
    static Mutex mutex = new Mutex();

    static void Main(string[] args)
    {
        Thread thread1 = new Thread(Worker1);
        Thread thread2 = new Thread(Worker2);
        thread1.Start();
        thread2.Start();
        Console.ReadKey();
        stop = true;
    }

    static void Worker1()
    {
        while (!stop)
        {
            mutex.WaitOne();
            Console.WriteLine("Worker1正在工作...");
            Thread.Sleep(100);
            mutex.ReleaseMutex();
        }
        Console.WriteLine("Worker1已停止");
    }

    static void Worker2()
    {
        while (!stop)
        {
            mutex.WaitOne();
            Console.WriteLine("Worker2正在工作...");
            Thread.Sleep(200);
            mutex.ReleaseMutex();
        }
        Console.WriteLine("Worker2已停止");
    }
}

上述示例中，使用Mutex类来创建一个互斥锁，确保同一时刻只有一个线程能够访问共享资源。Worker1和Worker2线程会多次等待互斥锁，并分别对共享资源进行访问。

示例二：信号量

using System;
using System.Threading;

class Program
{
    static Semaphore sem = new Semaphore(2, 2); // 初始信号量为2，最大信号量为2

    static void Main(string[] args)
    {
        for (int i = 1; i <= 5; i++)
        {
            Thread thread = new Thread(Worker);
            thread.Name = "Worker" + i;
            thread.Start();
        }
        Console.ReadKey();
    }

    static void Worker()
    {
        Console.WriteLine(Thread.CurrentThread.Name + "等待信号量");
        sem.WaitOne(); //等待信号量
        Console.WriteLine(Thread.CurrentThread.Name + "开始工作");
        Thread.Sleep(2000);
        Console.WriteLine(Thread.CurrentThread.Name + "结束工作");
        sem.Release(); // 释放信号量
    }
}

上述示例中，使用Semaphore类来表示一个具有初始信号量的信号灯。多个Worker线程会在开始之前等待信号灯，只有在获得信号之后才能开始工作。在工作结束之后会释放信号灯。

总结

本文介绍了C#多线程编程和同步操作的相关知识，并提供了两个示例来帮助读者更好地理解。在实际应用中，多线程和同步操作需要结合具体业务场景进行设计和调整，以达到最优的效果。