c#使用多线程的几种方式示例详解

《C#使用多线程的几种方式示例详解》

在C#开发中，多线程技术是提升程序性能、优化资源利用的核心手段之一。通过并行执行任务，可以显著减少阻塞时间，提高系统响应速度。本文将详细介绍C#中实现多线程的五种主流方式，包括Thread类、ThreadPool线程池、Task任务、async/await异步编程模型以及Parallel类，并通过完整代码示例展示其用法与差异。

一、Thread类：基础线程控制

Thread类是.NET中最基础的线程控制方式，允许开发者直接创建和管理线程生命周期。

1.1 基本用法

using System;
using System.Threading;

class ThreadExample
{
    static void Main()
    {
        Thread thread = new Thread(DoWork);
        thread.Start(); // 启动线程
        Console.WriteLine("主线程继续执行");
        thread.Join();  // 等待线程结束
        Console.WriteLine("所有线程完成");
    }

    static void DoWork()
    {
        Console.WriteLine("子线程开始工作");
        Thread.Sleep(2000); // 模拟耗时操作
        Console.WriteLine("子线程工作完成");
    }
}

输出结果：

主线程继续执行
子线程开始工作
子线程工作完成
所有线程完成

1.2 线程参数传递

通过ParameterizedThreadStart委托传递参数：

using System;
using System.Threading;

class ParameterizedThreadExample
{
    static void Main()
    {
        Thread thread = new Thread(DoWorkWithParam);
        thread.Start("Hello"); // 传递字符串参数
        thread.Join();
    }

    static void DoWorkWithParam(object param)
    {
        string message = (string)param;
        Console.WriteLine($"接收参数: {message}");
    }
}

1.3 线程优先级设置

ThreadPriority枚举控制线程调度优先级：

Thread thread = new Thread(DoWork);
thread.Priority = ThreadPriority.Highest; // 设置为最高优先级
thread.Start();

二、ThreadPool线程池：高效资源复用

ThreadPool适用于大量短生命周期任务，避免频繁创建销毁线程的开销。

2.1 基本使用

using System;
using System.Threading;

class ThreadPoolExample
{
    static void Main()
    {
        ThreadPool.QueueUserWorkItem(DoWork); // 排队任务到线程池
        Console.WriteLine("主线程继续执行");
        Thread.Sleep(3000); // 等待线程池任务完成
    }

    static void DoWork(object state)
    {
        Console.WriteLine("线程池任务执行中");
    }
}

2.2 设置最小线程数

通过SetMinThreads优化并发性能：

int minWorker, minIOC;
ThreadPool.GetMinThreads(out minWorker, out minIOC);
ThreadPool.SetMinThreads(10, 10); // 设置最小工作线程和IO线程数

三、Task类：现代异步编程基础

Task是.NET 4.0引入的抽象，提供更丰富的线程管理和结果获取能力。

3.1 创建并启动Task

using System;
using System.Threading.Tasks;

class TaskExample
{
    static void Main()
    {
        Task task = Task.Run(() => DoWork()); // 使用Task.Run简化创建
        Console.WriteLine("主线程继续执行");
        task.Wait(); // 同步等待任务完成
    }

    static void DoWork()
    {
        Console.WriteLine("Task任务执行中");
        Task.Delay(1000).Wait(); // 模拟异步延迟
    }
}

3.2 返回结果的Task

Task CalculateTask()
{
    return Task.Run(() => 
    {
        Thread.Sleep(500);
        return 42; // 返回计算结果
    });
}

// 调用方式
Task task = CalculateTask();
int result = task.Result; // 阻塞获取结果

3.3 任务链式调用

Task.Run(() => Console.WriteLine("第一步"))
    .ContinueWith(t => Console.WriteLine("第二步"))
    .ContinueWith(t => Console.WriteLine("第三步"));

四、async/await：真正的异步编程

async/await模式使异步代码编写如同同步代码般直观。

4.1 基本异步方法

using System;
using System.Threading.Tasks;

class AsyncExample
{
    static async Task Main() // 异步主方法
    {
        Console.WriteLine("主方法开始");
        await DoWorkAsync(); // 异步等待
        Console.WriteLine("主方法结束");
    }

    static async Task DoWorkAsync()
    {
        await Task.Delay(1000); // 异步延迟
        Console.WriteLine("异步任务完成");
    }
}

4.2 异步IO操作示例

using System.IO;
using System.Threading.Tasks;

class AsyncIOExample
{
    static async Task ReadFileAsync()
    {
        string content = await File.ReadAllTextAsync("test.txt");
        Console.WriteLine(content);
    }
}

4.3 异常处理

try
{
    await Task.Run(() => { throw new Exception("错误"); });
}
catch (Exception ex)
{
    Console.WriteLine($"捕获异常: {ex.Message}");
}

五、Parallel类：数据并行处理

Parallel类简化了数据并行和任务并行的实现。

5.1 Parallel.For循环

using System;
using System.Threading.Tasks;

class ParallelExample
{
    static void Main()
    {
        Parallel.For(0, 10, i => 
        {
            Console.WriteLine($"处理项 {i} 在线程 {Thread.CurrentThread.ManagedThreadId}");
        });
    }
}

5.2 Parallel.ForEach

string[] data = { "A", "B", "C", "D" };
Parallel.ForEach(data, item => 
{
    Console.WriteLine($"处理 {item}");
});

5.3 并行选项控制

var options = new ParallelOptions 
{
    MaxDegreeOfParallelism = 2 // 限制最大并行度
};
Parallel.For(0, 10, options, i => { /*...*/ });

六、多线程编程最佳实践

1. 线程安全：使用lock、Monitor或SemaphoreSlim保护共享资源

private static readonly object _lockObj = new object();
lock (_lockObj)
{
    // 临界区代码
}

2. 避免死锁：保持锁的获取顺序一致

3. 合理选择线程模型：

• 短期任务 → ThreadPool
• 需要返回结果 → Task
• IO密集型 → async/await
• 数据并行 → Parallel类

4. 取消支持：使用CancellationToken

var cts = new CancellationTokenSource();
Task.Run(() => 
{
    while (!cts.Token.IsCancellationRequested)
    {
        // 执行任务
    }
}, cts.Token);

// 外部取消
cts.Cancel();

七、性能对比分析

方式	创建开销	适用场景	复杂度
Thread	高	长期运行任务	★★★
ThreadPool	低	短生命周期任务	★
Task	中	需要结果的任务	★★
async/await	低	IO密集型操作	★
Parallel	中	数据并行处理	★★

关键词：C#多线程、Thread类、ThreadPool线程池、Task任务、async/await异步编程、Parallel类、线程安全、性能优化

简介：本文系统讲解C#中实现多线程的五种核心方式，包含Thread基础线程控制、ThreadPool高效资源复用、Task现代异步编程、async/await真正异步模式和Parallel数据并行处理。通过完整代码示例展示每种技术的用法与差异，并总结线程安全、死锁避免等最佳实践，最后提供性能对比分析帮助开发者根据场景选择最优方案。