站长之家域名查询大全,wordpress海淘,高特效网站,俄罗斯乌克兰最新局势最新消息线程是并发编程的基础概念之一。在现代应用程序中#xff0c;我们通常需要执行多个任务并行处理#xff0c;以提高性能。C# 提供了多种并发编程工具#xff0c;如Thread、Task、异步编程和Parallel等。 Thread 类
Thread 类是最基本的线程实现方法。使用Thread类#xff0… 线程是并发编程的基础概念之一。在现代应用程序中我们通常需要执行多个任务并行处理以提高性能。C# 提供了多种并发编程工具如Thread、Task、异步编程和Parallel等。 Thread 类
Thread 类是最基本的线程实现方法。使用Thread类我们可以创建并管理独立的线程来执行任务。
基本使用Thread
创建一个新的实例对象将一个方法直接给Thread类并使用实例对象启动线程运行。 static void Test() {Console.WriteLine(Test事件开始执行);Thread.Sleep(1000);Console.WriteLine(Test事件睡眠之后打印数据);Console.WriteLine(Test事件id: Thread.CurrentThread.ManagedThreadId);}static void Main(string[] args){#region //主线程idConsole.WriteLine(主线程id: Thread.CurrentThread.ManagedThreadId);#endregion#region //传递一个方法给线程执行方法Thread t new Thread(Test);t.Start();#endregion
}
线程数据传输
传递单个参数
Thread 提供了一个 Start(object parameter) 方法可以在启动线程时传递一个参数。
static int Downlod(object obj) {string str obj as string;Console.WriteLine(str);}static void Main(string[] args){Thread t1 new Thread(Downlod);//这里传递的参数是字符串t1.Start(数据传递方法执行 数据传递方法id Thread.CurrentThread.ManagedThreadId);}
这种方式适用于需要传递单个参数的情况。
使用类的实例方法传递多个参数
先new一个类的实例给实例字段赋值调用类的实例通过实例调用方法构造函数接收参数然后在线程中调用该实例的方法。 static void Main(string[] args){
// 使用 DownloadTool 实例化并传递数据
DownloadTool downloadTool new DownloadTool(www.baidu.com, 这是下载链接哦);
Thread thread new Thread(downloadTool.Download);
thread.Start();
}public class DownloadTool
{private string url;private string message;public DownloadTool(string url, string message){this.url url;this.message message;}public void Download(){Console.WriteLine(下载链接: url);Console.WriteLine(提示信息: message);Console.WriteLine(Download 线程 ID: Thread.CurrentThread.ManagedThreadId);}
}
当 thread 线程启动时它会执行 downloadTool.Download() 方法输出传递的数据。 线程优先级
在 C# 中可以使用 Thread.Priority 属性来设置线程的优先级。线程优先级决定了操作系统在多线程环境中调度线程的顺序但并不保证高优先级的线程总是比低优先级的线程更早或更频繁地执行。
线程优先级级别
C# 提供了五个线程优先级级别定义在 ThreadPriority 枚举中
Lowest最低优先级。操作系统尽可能少地调度这个优先级的线程。BelowNormal低于正常的优先级。优先级比 Normal 低但高于 Lowest。Normal默认优先级大多数线程默认的优先级。适用于一般用途。AboveNormal高于正常的优先级。操作系统更倾向于调度这个优先级的线程。Highest最高优先级。操作系统尽可能多地调度这个优先级的线程。 internal class Program{static void A(){int i 0;while (true){i;Console.WriteLine($A 输出第{i});Thread.Sleep(1000);}}static void B(){int i 0;while (true){i;Console.WriteLine($B 输出第{i});Thread.Sleep(1000);}}static void Main(string[] args){//在C#中线程的优先级可以通过Thread.Priority属性来设置和获取。
// Lowest: 线程的优先级是最低的。在系统中存在其他活动线程时此优先级的线程很少得到执行。
//BelowNormal: 线程的优先级低于正常线程。
//Normal: 线程的优先级是普通的这是线程的默认优先级。
//AboveNormal: 线程的优先级高于正常线程。
//Highest: 线程的优先级是最高的。此优先级的线程会尽量优先于其他所有优先级的线程执行。Thread a new Thread(A);Thread b new Thread(B);a.Priority ThreadPriority.Highest;a.Start();b.Priority ThreadPriority.Lowest;b.Start();Console.WriteLine(按任意键停止线程...);Console.ReadKey();a.Join();b.Join();Console.WriteLine(线程已停止);}}
A 被设置为最高优先级 ThreadPriority.Highest。B 被设置为最低优先级 ThreadPriority.Lowest。
注意事项 优先级不是绝对控制操作系统可能会忽略优先级设置特别是在资源有限的系统中。高优先级线程不一定会一直执行也不能阻止低优先级线程的执行。 使用优先级的适用场景设置线程优先级可能适用于实时系统例如某些任务需要优先处理。但是大多数应用程序通常可以使用默认的 Normal 优先级。 避免使用过多的高优先级线程如果所有线程都被设置为 Highest系统的整体性能可能会下降甚至导致线程争用 CPU 资源的情况。 CPU 密集型任务在 CPU 密集型任务中优先级可能会对性能产生较大影响因为优先级高的线程可能会占用更多的 CPU 时间。
线程优先级的最佳实践
默认使用 Normal 优先级除非有特殊原因。避免滥用 Highest 优先级因为它会对系统资源产生影响。在 I/O 密集型的线程中优先级通常不会有显著差异因为这些线程在等待 I/O 操作完成时CPU 会调度其他线程。
通过合理设置线程优先级可以帮助操作系统更好地调度线程以满足应用程序的需求。 但通常在 .NET 应用程序中多数情况下使用默认的 Normal 优先级就足够了。
线程池
线程池 (ThreadPool) 是一种高效的管理和调度线程的方式。线程池自动管理线程的创建、重用和销毁从而减少了手动创建和管理线程的开销。
为什么使用线程池
性能更高线程池会重用现有的线程减少了创建和销毁线程的开销。自动管理线程池会根据系统负载动态调整线程数量。避免线程资源不足线程池限制了同时运行的线程数避免了线程过多导致的资源耗尽问题。
基本使用 ThreadPool.QueueUserWorkItem 方法将任务排入线程池队列。
using System;
using System.Threading;class Program
{static void Main(string[] args){// 将任务排入线程池ThreadPool.QueueUserWorkItem(DoWork, 任务 1);ThreadPool.QueueUserWorkItem(DoWork, 任务 2);Console.WriteLine(主线程完成);Thread.Sleep(3000); // 等待线程池中的任务完成}static void DoWork(object state){string taskName (string)state;Console.WriteLine(${taskName} 开始执行 - 线程ID: {Thread.CurrentThread.ManagedThreadId});Thread.Sleep(1000); // 模拟耗时操作Console.WriteLine(${taskName} 执行完成 - 线程ID: {Thread.CurrentThread.ManagedThreadId});}
}运行结果QueueUserWorkItem自动分配线程来执行任务。 QueueUserWorkItem 方法将任务排入线程池。它接收一个委托即方法和一个可选的状态对象传递给方法的数据。
DoWork 方法接受一个参数 state这是从 QueueUserWorkItem 传递的。
Thread.Sleep(3000) 确保主线程不会立即退出使得线程池中的任务有机会完成。
使用带返回值的线程池任务
C# 中的 ThreadPool 通常不直接支持返回值。如果需要获得任务结果可以使用 Task因为 Task 本质上也是线程池的一部分。Task 更适合于带返回值的异步操作。这里使用 Task.Run 来代替 ThreadPool static void Main(string[] args){//使用tesk多线程int a Task.Run(() {int a Dowload();return a;}).Result;Taskint task Taskint.Run((){int a Dowload();return a;});//初始化一个CancellationTokenSource实例CancellationTokenSource source new CancellationTokenSource();//task.Start();task.Wait(1000);source.Cancel();int result task.Result;Console.WriteLine(result);Console.WriteLine($tesk返回值{a});
}static int Dowload() {int a 0;for (int i 0; i 10; i){a a i 1;}int? id Task.CurrentId;Console.WriteLine(Current thread ID: id);return a;}线程池的限制
任务运行时间过长线程池中的线程本质上是共享资源如果某个任务运行时间太长将会占用线程池中的线程导致其他任务无法及时执行。不适合实时系统线程池中的任务调度是由系统管理的无法保证精确的实时性。有限的线程数量在高并发场景中如果线程池中的线程全部被占用新的任务将会等待直到有线程可用。
线程池总结
线程池是一种高效的并发处理方式适合于大多数轻量级的后台任务。在现代 C# 编程中建议使用 Task 和 async/await 进行异步操作因为它们能简化代码并且使用底层的线程池来管理线程。如果需要精确控制线程的执行通常建议使用手动管理的 Thread 等。 线程锁
使用多线程在多线程编程中如果多个线程同时访问和修改共享资源如全局变量、文件、数据库等可能会导致数据不一致或竞争条件。为了避免这种情况多线程锁通过控制对共享资源的访问来保证线程安全性。
资源冲突示例 static void Main(string[] args){//调用方法循环创建新的线程来执行方法StateObject state new StateObject();for (int i 0; i 30; i){Thread thread new Thread(state.ChangState);thread.Start();}Console.ReadKey();}//一个StateObject类public class StateObject{private int state 5;
//里面有个状态改变方法当状态等于5的时候进入到方法中然后state1 打印的应该是6 和线程idpublic void ChangState(){if (state 5){state;Console.WriteLine($state{state} 线程id Thread.CurrentThread.ManagedThreadId);}state 5;}} 运行结果
因为资源冲突的原因有一些线程执行的时候可能另外一个线程没有执行完另外一个线程就已经进入到方法里面了。因为有修改的操作导致State状态混乱资源冲突。这时候我们就需要一个东西来维护让线程执行指定方法时一个一个的执行不会冲突。 简单使用lock锁
1.创建一个private readonly object lockObject new object(); // 锁对象
2.使用lock (lockObject){
//业务代码执行到有修改的操作的代码
} // 使用锁对象来确保线程安全 static void Main(string[] args){StateObject state new StateObject();for (int i 0; i 100; i){Thread thread new Thread(state.ChangState);thread.Start();}Console.ReadKey();}public class StateObject{private object _lock new object();private int state 5;public void ChangState(){//使用锁保证每次执行方法的都是一个线程防止资源冲突lock (_lock){if (state 5){state;Console.WriteLine($state{state} 线程id Thread.CurrentThread.ManagedThreadId);}state 5;}}} 这样运行起来就能把每个线程操作隔离开保证state的状态不会冲突。 为什么要创建一个 object 对象作为锁
专用性创建一个专用的锁对象如 private readonly object lockObject new object();可以确保锁定的是特定的同步逻辑而不是其他对象。这有助于避免意外的锁冲突或死锁。避免使用其他共享对象虽然可以使用任意的引用类型对象作为锁对象包括 this 或 Type 对象但这可能会带来不必要的风险尤其是在 public 方法或对象中这样可能会导致意外的锁定冲突。 常见问题死锁
锁并不是万能也不是有锁就是最好要看情况使用锁也会产生问题常见的问题就是死锁等问题。
演示死锁
thread1方法1 的锁里面嵌套锁住了thread2的锁thread2方法2的锁里面嵌套锁住了thread1的锁这种锁与锁嵌套使用就是容易出问题。导致线程锁死程序无法动弹。 static void Main(string[] args){DeadlockExample deadlockExample new DeadlockExample();Thread t1 new Thread(deadlockExample.Thread1);Thread t2 new Thread(deadlockExample.Thread2);t1.Start();t2.Start();t1.Join();t2.Join();Console.ReadKey();}}public class DeadlockExample{private static object lock1 new object();private static object lock2 new object();public void Thread1(){lock (lock1){Console.WriteLine(线程1已获取锁1正在等待锁2。。。);Thread.Sleep(100); // 模拟某些工作lock (lock2){Console.WriteLine(线程1获得锁2);}}}public void Thread2(){lock (lock2){Console.WriteLine(线程2已获取锁2正在等待锁1。。。);Thread.Sleep(100); // 模拟某些工作lock (lock1){Console.WriteLine(线程2获得锁1);}}}}
运行结果
死锁发生在两个或多个线程相互等待对方持有的资源导致所有线程都无法继续执行。 总结
多线程锁在 C# 中主要用于解决以下问题
竞态条件通过锁机制防止多个线程同时访问和修改共享资源确保数据一致性。死锁防止多个线程相互等待资源通过锁的顺序或者避免嵌套锁来解决。资源饥饿确保每个线程都能获取资源使用 Monitor.TryEnter 等机制防止无限等待。读写锁允许多个线程并发读取资源但写入时互斥适合读多写少的场景。
C# 提供了多种锁机制开发者可以根据应用场景选择合适的锁类型。
如果不想使用 lock 关键字C# 还提供了其他锁机制比如 Mutex、Semaphore、Monitor 等
