在C#中，Task.Run 并不一定会创建一个独立的线程。它实际上是将任务放入线程池中执行，线程池中的线程是共享的，而不是为每个任务创建新的独立线程。
1.Task.Run的工作原理
- 线程池：
Task.Run默认使用线程池来执行任务。线程池中的线程是预先创建好的，并且可以被多个任务共享。这样可以减少线程创建和销毁的开销。 - 异步执行：
Task.Run会将任务放入线程池中异步执行，这意味着任务不会阻塞调用线程（通常是主线程）。
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("主线程开始");
// 使用 Task.Run 执行任务
Task task = Task.Run(() => DoWork());
// 主线程继续执行其他任务
for (int i = 0; i < 5; i++)
{
Console.WriteLine("主线程: " + i);
await Task.Delay(500);
}
// 等待任务完成
await task;
Console.WriteLine("主线程结束");
}
static void DoWork()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine("工作线程: " + i);
Thread.Sleep(500);
}
}
}
执行结果
主线程开始 主线程: 0 工作线程: 0 主线程: 1 工作线程: 1 主线程: 2 工作线程: 2 主线程: 3 工作线程: 3 主线程: 4 工作线程: 4 主线程结束
- 线程池线程：
Task.Run使用的是线程池中的线程，而不是独立的线程。线程池中的线程是共享的，任务完成后线程会返回到线程池中，供其他任务使用。 - 异步执行：
Task.Run是异步执行的，不会阻塞调用线程。 - 任务调度：
Task.Run会自动处理任务的调度和执行，开发者不需要手动管理线程。
2.问题
如果多个任务同时访问和修改共享数据（如全局变量、静态变量、集合等），而没有进行适当的同步控制，就可能导致数据竞争（Race Condition），从而出现数据被覆盖或损坏的情况。
using System;
using System.Threading.Tasks;
class Program
{
static int sharedData = 0; // 共享数据
static async Task Main(string[] args)
{
Task[] tasks = new Task[10];
// 启动10个任务并发修改共享数据
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => ModifySharedData());
}
// 等待所有任务完成
await Task.WhenAll(tasks);
Console.WriteLine("最终共享数据: " + sharedData);
}
static void ModifySharedData()
{
for (int i = 0; i < 1000; i++)
{
sharedData++; // 并发修改共享数据
}
}
}
问题分析：
- 多个任务同时执行
sharedData++，这是一个非原子操作（读取、修改、写入）。 - 由于没有同步控制，多个任务可能会同时读取
sharedData的旧值，然后各自加1并写回，导致部分修改丢失。 - 最终
sharedData的值可能小于预期值（如小于 10000）。
如何避免数据覆盖？
（1）使用lock关键字
lock 可以确保同一时间只有一个线程访问共享数据。
using System;
using System.Threading.Tasks;
class Program
{
static int sharedData = 0; // 共享数据
static readonly object lockObject = new object(); // 锁对象
static async Task Main(string[] args)
{
Task[] tasks = new Task[10];
// 启动10个任务并发修改共享数据
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => ModifySharedData());
}
// 等待所有任务完成
await Task.WhenAll(tasks);
Console.WriteLine("最终共享数据: " + sharedData);
}
static void ModifySharedData()
{
for (int i = 0; i < 1000; i++)
{
lock (lockObject) // 加锁
{
sharedData++; // 安全地修改共享数据
}
}
}
}
（2）使用Interlocked类
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static int sharedData = 0; // 共享数据
static async Task Main(string[] args)
{
Task[] tasks = new Task[10];
// 启动10个任务并发修改共享数据
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => ModifySharedData());
}
// 等待所有任务完成
await Task.WhenAll(tasks);
Console.WriteLine("最终共享数据: " + sharedData);
}
static void ModifySharedData()
{
for (int i = 0; i < 1000; i++)
{
Interlocked.Increment(ref sharedData); // 原子操作
}
}
}
（3）使用线程安全集合
如果共享数据是集合（如 List<T>），可以使用线程安全的集合（如 ConcurrentBag<T>、ConcurrentQueue<T> 等）。
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
class Program
{
static ConcurrentBag<int> sharedData = new ConcurrentBag<int>(); // 线程安全的集合
static async Task Main(string[] args)
{
Task[] tasks = new Task[10];
// 启动10个任务并发添加数据
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => AddData());
}
// 等待所有任务完成
await Task.WhenAll(tasks);
Console.WriteLine("最终共享数据数量: " + sharedData.Count);
}
static void AddData()
{
for (int i = 0; i < 1000; i++)
{
sharedData.Add(i); // 线程安全地添加数据
}
}
}
3.如果需要独立线程
如果你确实需要创建一个独立的线程（而不是使用线程池），可以使用 Thread 类：
using System;
using System.Threading;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("主线程开始");
// 创建一个独立线程
Thread thread = new Thread(DoWork);
thread.Start();
// 主线程继续执行其他任务
for (int i = 0; i < 5; i++)
{
Console.WriteLine("主线程: " + i);
Thread.Sleep(500);
}
// 等待独立线程完成
thread.Join();
Console.WriteLine("主线程结束");
}
static void DoWork()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine("独立线程: " + i);
Thread.Sleep(500);
}
}
}