当前位置：首页 > article >正文

C# 多线程编程

article 2024/11/14 5:37:10

文章目录

前言
- 1.什么是多线程？
- 2.C#多线程编程
- - 2.1 使用 Thread 类
  - 2.2 使用 ThreadPool（线程池）
  - 2.3 使用 Task 类
  - 2.4 async 和 await 异步编程
- 3.线程同步与锁机制
- - 3.1 使用 lock
- 4.常见应用场景

前言

多线程编程是现代应用程序开发中提高程序并发执行能力的关键技术之一。C# 提供了强大的多线程支持，包括基础的 Thread 类、ThreadPool、Task 和 async/await 等高级特性。

1.什么是多线程？

在一个应用程序中，多线程允许同时执行多个任务。多线程编程可以在不增加应用程序主线程负担的情况下，处理耗时的任务（如文件 I/O、网络请求）和复杂计算，使得应用程序更高效、更具响应性。

2.C#多线程编程

C# 中有多种实现多线程的方法，最常用的包括：

Thread 类：用于直接创建和管理线程。
ThreadPool：管理一个线程池，允许系统管理线程的创建和回收。
Task：提供任务并发的高级抽象，更适合处理复杂任务和依赖关系。
async/await：用于异步编程，通过标记异步方法以便它们在执行时不会阻塞调用线程。

2.1 使用 Thread 类

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建线程并指定要执行的方法
        Thread thread = new Thread(PrintNumbers);
        thread.Start();

        // 主线程继续执行
        Console.WriteLine("主线程正在执行其他任务...");
    }

    static void PrintNumbers()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine("线程输出: " + i);
            Thread.Sleep(1000); // 让线程休眠1秒
        }
    }
}

在这个示例中，我们创建了一个新线程，执行 PrintNumbers 方法，而主线程则继续执行自己的任务。通过 Thread.Sleep 让线程休眠一段时间，可以模拟耗时任务的执行。

2.2 使用 ThreadPool（线程池）

ThreadPool 提供了更高效的线程管理方式。线程池会自动管理线程的创建和回收，适合用于短期、无状态任务。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 使用线程池启动任务
        ThreadPool.QueueUserWorkItem(PrintNumbers);
        Console.WriteLine("主线程正在执行其他任务...");
    }

    static void PrintNumbers(object state)
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine("线程池线程输出: " + i);
            Thread.Sleep(1000);
        }
    }
}

在这个示例中，ThreadPool.QueueUserWorkItem 用于将任务提交到线程池，不需要显式地创建和管理线程。

2.3 使用 Task 类

Task 类提供了任务并发的高级抽象，非常适合用于复杂的任务管理，并支持任务之间的依赖关系。Task 还可以与 async/await 结合使用，使得异步编程更加简洁。

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // 启动任务并等待结果
        Task task = Task.Run(() => PrintNumbers());
        await task; // 等待任务完成

        Console.WriteLine("主线程任务完成");
    }

    static void PrintNumbers()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine("Task 输出: " + i);
            Task.Delay(1000).Wait(); // 任务延迟1秒
        }
    }
}

在这个示例中，Task.Run 创建一个任务并在后台执行。通过 await 等待任务完成，确保任务执行完毕后才继续往下执行。

2.4 async 和 await 异步编程

异步编程使得任务执行不会阻塞主线程，特别适合用在 I/O 操作和网络请求等耗时任务中。以下是一个 async 和 await 的示例：

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        await PrintNumbersAsync();
        Console.WriteLine("主线程任务完成");
    }

    static async Task PrintNumbersAsync()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine("异步输出: " + i);
            await Task.Delay(1000); // 异步延迟1秒
        }
    }
}

在这里，PrintNumbersAsync 方法是异步的，await Task.Delay 会在等待时释放当前线程，不会阻塞其他任务的执行。

3.线程同步与锁机制

在多线程环境中，多个线程同时访问共享数据时，可能会产生竞争条件，导致数据不一致的问题。C# 提供了多种线程同步机制：

lock 语句：锁定代码块，防止多个线程同时访问共享资源。
Monitor 类：提供类似 lock 的功能，但更加灵活。
Mutex 和 Semaphore：用于跨进程同步，允许多个线程或进程访问有限的资源。

3.1 使用 lock

using System;
using System.Threading;

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

    static void Main()
    {
        Thread thread1 = new Thread(IncrementCounter);
        Thread thread2 = new Thread(IncrementCounter);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("最终计数: " + counter);
    }

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