C#实现多线程编程的简单案例

下面是 C# 实现多线程编程的简单案例的攻略，分为以下几个步骤：

1. 确定需求及问题

在开始之前，需要确定要实现的需求和问题，这样才能更有针对性地编写代码。例如，本次案例要实现的问题可能是：在一个列表中，同时处理多个元素的计算任务，并等待所有计算任务完成后，将结果汇总并输出。

2. 创建多线程

在确定了需求和问题后，需要使用 C# 中的多线程机制来实现。创建线程有两种方法：

1. 继承 Thread 类：可以定义一个类继承 Thread 类，并覆盖其运行方法 Run()，在此方法中执行需要多线程执行的代码。通过实例化该子类，并调用其 Start() 方法，即可启动一个新的线程。

下面是继承 Thread 类创建多线程的示例代码：

using System;
using System.Threading;

public class MyThread : Thread {
    public string message;

    public MyThread(string message) {
        this.message = message;
        // 在构造函数中，初始化线程对象并设置名称
        this.Name = "MyThread";
        // 设置为后台线程（如果不设置，默认是前台线程）
        this.IsBackground = true;
    }

    // 定义运行方法
    public override void Run() {
        Console.WriteLine(message);
    }
}

// 在主线程中启动 MyThread
public class Program {
    static void Main(string[] args) {
        MyThread mt = new MyThread("Hello, World!");
        mt.Start();
    }
}

1. 创建委托和线程池：创建一个委托，该委托中执行需要多线程执行的代码，再通过线程池中的线程来执行该委托。

下面是使用线程池创建多线程的示例代码：

using System;
using System.Threading;

public class MyThreadPool {
    public static void DoWork(object state) {
        string message = (string)state;
        Console.WriteLine(message);
    }
}

// 在主线程中使用线程池来执行任务
public class Program {
    static void Main(string[] args) {
        // 将要执行的任务添加到线程池中
        ThreadPool.QueueUserWorkItem(new WaitCallback(MyThreadPool.DoWork), "Hello, World!");
        // 确保所有任务都完成了，再执行下一步操作
        ThreadPool.WaitAll(new WaitHandle[0], 5000);
    }
}

3. 多线程间的同步

在多线程编程中，线程间的同步是非常重要的。为了防止线程间访问同一共享资源，导致数据错乱，需要使用特定的方法来进行同步。C# 中常见的同步机制有：

1. lock 关键字：用于给对象加锁，避免多个线程同时访问造成数据冲突。

下面是使用 lock 关键字进行同步的示例代码：

using System;
using System.Threading;

public class Counter {
    public int count;

    public Counter() {
        count = 0;
    }

    // 原子操作运算
    public void Increment() {
        lock (this) {
            count++;
        }
    }

    // 输出计数器的值
    public void PrintCount() {
        Console.WriteLine("count: " + count);
    }
}

// 使用 Counter 类和 lock 关键字在多线程中同步计数器
public class Program {
    static void Main(string[] args) {
        Counter counter = new Counter();

        // 创建多个线程来执行计数器的增加操作
        Thread t1 = new Thread(new ThreadStart(() => {
            for (int i = 0; i < 100000; i++) {
                counter.Increment();
            }
        }));

        Thread t2 = new Thread(new ThreadStart(() => {
            for (int i = 0; i < 100000; i++) {
                counter.Increment();
            }
        }));

        t1.Start();
        t2.Start();

        // 等待所有线程执行完成
        t1.Join();
        t2.Join();

        // 输出计数器的结果
        counter.PrintCount();
    }
}

1. Interlocked 类：提供了多种原子性操作方法，可以用于在多线程中进行同步。

下面是使用 Interlocked 类进行同步的示例代码：

using System;
using System.Threading;

public class Counter {
    public int count;

    public Counter() {
        count = 0;
    }

    // 原子操作运算
    public void Increment() {
        Interlocked.Increment(ref count);
    }

    // 输出计数器的值
    public void PrintCount() {
        Console.WriteLine("count: " + count);
    }
}

// 使用 Counter 类和 Interlocked 类在多线程中同步计数器
public class Program {
    static void Main(string[] args) {
        Counter counter = new Counter();

        // 创建多个线程来执行计数器的增加操作
        Thread t1 = new Thread(new ThreadStart(() => {
            for (int i = 0; i < 100000; i++) {
                counter.Increment();
            }
        }));

        Thread t2 = new Thread(new ThreadStart(() => {
            for (int i = 0; i < 100000; i++) {
                counter.Increment();
            }
        }));

        t1.Start();
        t2.Start();

        // 等待所有线程执行完成
        t1.Join();
        t2.Join();

        // 输出计数器的结果
        counter.PrintCount();
    }
}

4. 示例应用

下面是一个简单示例应用，实现了在一个列表中，同时处理多个元素的计算任务，并等待所有计算任务完成后，将结果汇总并输出。

using System;
using System.Collections.Generic;
using System.Threading;

public class Task {
    public int taskId { get; set; }
    public int input { get; set; }
    public int result { get; set; }
    public ManualResetEventSlim evt { get; set; }

    // 构造方法
    public Task(int id, int input) {
        taskId = id;
        this.input = input;
        evt = new ManualResetEventSlim(false);
    }

    // 计算任务的方法
    public void Compute() {
        Thread.Sleep(500); // 模拟耗时计算
        result = input * input;
        evt.Set(); // 完成任务时，通知等待的线程
    }
}

public class Program {
    static void Main(string[] args) {
        // 创建任务列表
        List<Task> taskList = new List<Task>();
        for (int i = 1; i <= 10; i++) {
            taskList.Add(new Task(i, i));
        }

        // 执行计算任务
        foreach (Task task in taskList) {
            ThreadPool.QueueUserWorkItem(new WaitCallback((object state) => {
                Task t = (Task)state;
                t.Compute();
            }), task);
        }

        // 等待所有计算任务完成
        foreach (Task task in taskList) {
            task.evt.Wait();
        }

        // 输出结果
        int sum = 0;
        foreach (Task task in taskList) {
            Console.WriteLine("Task {0}: input={1}, result={2}", task.taskId, task.input, task.result);
            sum += task.result;
        }
        Console.WriteLine("Sum: " + sum);
    }
}

以上就是 C# 实现多线程编程的简单案例的攻略，希望能对您有所帮助。