C#多线程学习总结

女爷i 2024-04-01 06:32 43阅读 0赞

![在这里插入图片描述][19e7eabd3ee4487eb1917e011c76a55b.png]  
线程的基础概念  
操作系统能够优先访问CPU,并能够调整不同程序访问CPU的优先级，避免某一个程序独占CPU的情况发生。  
可以认为线程是一个虚拟进程，用于独立运行一个特定的程序。  
线程会消耗大量的操作系统资源，多个线程共享一个物理处理器将导致操作系统忙于管理这些线程，而无法运行程序  
在单核cpu上并行执行计算任务是没有意义的。  
在多核cpu上可以使用多线程有效的利用多个cpu的计算能力。这需要组织多个线程间的通信和相互同步。  
线程的基本操作  
线程的生命周期包括：创建线程 、挂起线程、线程等待、终止线程

创建线程  
通过new 一个Thread对象并指定线程执行函数创建线程。调用Start方法开启线程

///  
/// 线程启动函数  
///  
static void PrintNums()  
\{  
Console.WriteLine(“starting …”);  
for (int i = 0; i < 10; i++)  
\{  
Console.WriteLine(i);  
\}  
Console.WriteLine(“end…”);  
\}  
/// 创建一个线程  
public static void Main()  
\{  
Thread thread = new Thread(PrintNums);  
thread.Start();  
PrintNums();//主线程调用  
\}  
暂停当前线程  
通过在线程函数中调用Thread.Sleep()暂停当前线程，使线程进入休眠状态。此时线程会占用尽可能少的CPU时间。

//暂停线程  
static void PrintNumsWithDelay()  
\{  
Console.WriteLine(“starting …”);  
//Log(“当前线程状态 :” + Thread.CurrentThread.ThreadState.ToString());  
for (int i = 0; i < 10; i++)  
\{  
Thread.Sleep(TimeSpan.FromSeconds(1)); //每次暂停一秒  
Console.WriteLine(i);  
\}  
Console.WriteLine(“end…”);  
\}

//创建一个线程并暂停
        public static void Test1()
        {
            Thread t = new Thread(PrintNumsWithDelay);
            t.Start();
            PrintNums();//主线程调用
        }

线程等待  
假设有线程t,在主程序中调用了t.Join()方法,该方法允许我们等待直到线程t完成。当线程t完成 时,主程序会继续运行。借助该技术可以实现在两个线程间同步执行步骤。第一个线程会等待另一个线程完成后再继续执行。第一个线程等待时是处于阻塞状态(正如暂停线程中调用 Thread.Sleep方法一样)

///  
/// 在主线程中等待线程执行玩  
///  
public static void Main()  
\{  
Thread t1 = new Thread(PrintNumsWithDelay);  
t1.Start();  
t1.Join(); //等待线程t1执行完成,程序会在这里阻塞  
Console.WriteLine(“Thread t1 finished”);  
\}  
终止线程  
通过调用Thread.Abort()方法强制终止线程。这会给线程注入ThreadAbortExeception方法，导致线程被终结。这是一个非常危险的操作， 任何时刻发生并可能彻底摧毁应用程序。另外,使用该技术也不一定总能终止线程。目标线程可以通过处理该异常并调用Thread.ResetAbort方法来拒绝被终止。因此并不推荐使用,Abort方法来关闭线程 。

///  
/// 终止线程 非常危险,不推荐使用,也不一定能够终止线程  
///  
public static void Main()  
\{  
Thread t = new Thread(PrintNumsWithDelay);  
t.Start();  
//5s之后终止线程t  
Thread.Sleep(5000);  
t.Abort();  
Console.WriteLine(“Thread t has been Abort”);  
\}  
获取线程状态  
线程状态位于Thread对象的ThreadState属性中。ThreadState属性是一个C\#枚举对象。刚开始线程状态为ThreadState.Unstarted,然后我们启动线程,线程状态会从ThreadState.Running变为ThreadState. WaitSleepJoin。 其中：请注意始终可以通过Thread.CurrentThread静态属性获得当前Thread对象。

///  
/// 线程状态  
///  
public static void Test5()  
\{  
Thread t1 = new Thread(PrintNumsWithDelay);  
Log(“t1线程状态 :” + t1.ThreadState.ToString());  
t1.Start();  
Log(“t1线程状态 :” + t1.ThreadState.ToString());  
t1.Join(); //等待线程t1执行完成,程序会在这里阻塞  
Log(“t1线程状态 :” + t1.ThreadState.ToString());  
Console.WriteLine(“Thread t1 finished”);  
Log(“t1线程状态 :” + t1.ThreadState.ToString());  
\}  
线程优先级  
通过设置Thread.Priority属性给线程对象设置优先级 ThreadPriority.Highest (最高优先级)、 ThreadPriority.Lowest(最低优先级)。通常优先级更高的线程将获取到更多cpu时间。

///  
/// 线程优先级  
///  
class ThreadSample  
\{  
private bool isStop = false;

public void Stop()
            {
                isStop = true;
            }
    
            public void CountNums()
            {
                long counter = 0;
                while (!isStop)
                {
                    counter++;
                }
                Console.WriteLine("{0} with {1,11} priority has a count = {2,13}"
                    ,Thread.CurrentThread.Name,Thread.CurrentThread.Priority,
                    counter.ToString());
            }
        }
        static void RunThreads()
        {
            //启动两个线程t1 t2
            var sample = new ThreadSample();
            Thread t1 = new Thread(sample.CountNums);
            t1.Name = "Thread1";
            Thread t2 = new Thread(sample.CountNums);
            t2.Name = "Thread2";
            //设置线程的优先级
            t1.Priority = ThreadPriority.Highest;  //t1为最高优先级
            t2.Priority = ThreadPriority.Lowest;  //t2为最低优先级
            //启动
            t1.Start();
            t2.Start();
    
            //主线程阻塞2s
            Thread.Sleep(TimeSpan.FromSeconds(2));
            sample.Stop();  //停止计数
            //等待按键按下
            Console.ReadKey();
        }
        /// <summary>
        /// 线程优先级，决定该线程可以占用多少cpu时间
        /// </summary>
        public static void Test6()
        {
            Log("当前线程的优先级 priority = " + Thread.CurrentThread.Priority.ToString());
            Log("在所有核上运行");
    
            RunThreads();
    
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Log("在单个核上运行");
            //在该进程下的线程只能在一个核上运行
            Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
            //再次执行
            RunThreads();
    
            /*
             结果:多核时高优先级的线程通常会比低优先级的线程多执行次数 但是大体接近
                单核的时候竞争就更激烈了，用有高优先级的线程会占用更多的cpu时间,而留给低优先级的线程的
                cpu时间就更少了。
             * 在所有核上运行
                Thread1 with     Highest priority has a count =     583771892
                Thread2 with      Lowest priority has a count =     444097830
                在单个核上运行
                Thread2 with      Lowest priority has a count =      32457242
                Thread1 with     Highest priority has a count =    6534967709
             * 
             */
        }

前台线程和后台线程  
当主程序启动时定义了两个不同的线程。默认情况下,显式创建的线程是前台线程。通过手动的设置Thread对象的IsBackground属性为ture来创建一个后台线程。  
前台线程与后台线程的主要区别: 进程会等待所有的前台线程完成后再结束工作,但是如果只剩下后台线程,则会直接结束工作。  
如果程序定义了一个不会完成的前台线程,主程序并不会正常结束。  
///  
/// 前台线程和后台线程  
///

class ThreadSample2
           {
               private int iterCount = 0;
    
               public ThreadSample2(int count)
               {
                   this.iterCount = count;
               }
    
               public void CountNum()
               {
                   for (int i = 0; i <= iterCount; i++)
                   {
                       Thread.Sleep(500); //挂起0.5s
                       //输出次数
                       Console.WriteLine("{0} prints {1}",Thread.CurrentThread.Name,i);
                   }
    
                   Log("Thread Finished ： " + Thread.CurrentThread.Name);
               }
    
           }
           public static void Test7()
           {
               ThreadSample2 samp1 = new ThreadSample2(10);
               ThreadSample2 samp2 = new ThreadSample2(20);
    
               //启动两个线程t1,t2,并讲其中一个设置为后台线程 默认是前台线程
               Thread t1 = new Thread(samp1.CountNum);
               t1.Name = "Foreground";
               Thread t2 = new Thread(samp2.CountNum);
               t2.Name = "Background";
               t2.IsBackground = true;  //设置为后台线程
    
               //启动
               t1.Start();
               t2.Start();
    
               //进程会等所有的前台程序结束完之后才结束；如果只剩下后台程序，则进程会直接结束
           }

向线程中传递参数  
启动线程的时候需要向线程函数中传递参数，一般有三种方式。

将线程函数声明为一个类的成员函数，通过类的成员变量来传递参数。  
声明一个静态函数当作线程的执行函数，该函数接受一个object类型的参数param，这个参数可以通过Thread.Start(param)传递到线程中。  
通过lambda表达式的闭包机制传递参数，原理等同于1。C\#编辑器会帮我们实现这个类。  
///  
/// 向线程中传递参数  
///

public static  void CountNum(int iterCount)
           {
               for (int i = 0; i <= iterCount; i++)
               {
                   Thread.Sleep(500); //挂起0.5s
                   //输出次数
                   Console.WriteLine("{0} prints {1}",Thread.CurrentThread.Name,i);
               }
    
               Log("Thread Finished ： " + Thread.CurrentThread.Name);
           }
    
           //方法3：通过object类型的参数传递,参数parma在Start()函数中传递
           public static void Count(object param)
           {
               CountNum((int) param);
           }
    
    
           public static void Test8()
           {
               Thread t1 = new Thread(Count);
               t1.Start(6);  //传递参数
    
               //方法3 通过lamda表达式
               int num = 8;
               Thread t2 = new Thread(()=>{ CountNum(num);});
               num = 12;
               Thread t3 = new Thread(() => { CountNum(num);});
               t2.Start();
               t3.Start();
    
           }

线程锁的使用  
当多个线程同时访问一个资源的时候，容易形成竞争条件，导致错误的产生。为了确保不会发生这种情况，需要保证当前线程1在访问变量A的时候，其他线程必须等待直到线程1完成当前操作。  
如果锁定了一个对象,需要访问该对象的所有其他线程则会处于阻塞状态,并等待直到该对象解除锁定。这,可能会导致严重的性能问题。  
可以使用lock关键字来进行加锁操作  
public abstract class BaseCounter  
\{  
public abstract void Add();  
public abstract void Del();  
public abstract long GetRes();  
\}

/// <summary>
           /// 线程不安全的计数器
           /// </summary>
           public class Counter : BaseCounter
           {
               private long counter;
               public override void Add()
               {
                   counter++;
               }
    
               public override void Del()
               {
                   counter--;
               }
    
               public override long GetRes()
               {
                   return counter;
               }
           }
    
           /// <summary>
           /// 线程安全的计数器
           /// </summary>
           public class ThreadSafeCounter : BaseCounter
           {
               /// <summary>
               /// 线程锁对象 
               /// </summary>
               private readonly  object lockObj = new object();
    
               private long counter;
               public override void Add()
               {
                   lock (lockObj)  //锁定一个对象,需要访问该对象的所有其他线程就会处于阻塞状态，并等待直到该对象接触锁定
                   {
                       counter++;
                   }
    
               }
    
               public override void Del()
               {
                   lock (lockObj)
                   {
                       counter--;
                   }
               }
    
               public override long GetRes()
               {
                   return counter;
               }
           }
    
           /// <summary>
           /// 线程函数 测试计数器
           /// </summary>
           /// <param name="c"></param>
           static void TestCounter(BaseCounter c)
           {
               for (int i = 0; i < 10000000; i++)
               {
                   c.Add();
                   c.Del();
               }
           }
    
           public static void TestLock()
           {
               //测试不安全的计数器
               //创建3个线程同时对计数器进行加减
               Counter c = new Counter();
               Thread t1 = new Thread(() => { TestCounter(c);});
               Thread t2 = new Thread(() => { TestCounter(c);});
               Thread t3 = new Thread(() => { TestCounter(c);});
               t1.Start();
               t2.Start();
               t3.Start();
               t1.Join();
               t2.Join();
               t3.Join();
               //等三个线程都执行完之后打印结果 看是否为0
               Console.WriteLine("count =   " + c.GetRes());
    
    
               //测试线程安全的计数器
               //创建3个线程同时对计数器进行加减
               ThreadSafeCounter c1 = new ThreadSafeCounter();
                t1 = new Thread(() => { TestCounter(c1);});
                t2 = new Thread(() => { TestCounter(c1);});
                t3 = new Thread(() => { TestCounter(c1);});
               t1.Start();
               t2.Start();
               t3.Start();
               t1.Join();
               t2.Join();
               t3.Join();
               //等三个线程都执行完之后打印结果 看是否为0
               Console.WriteLine("count =   " + c1.GetRes());
    
           }

死锁的产生  
什么是死锁：  
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。 因此我们举个例子来描述，如果此时有一个线程A，按照先锁a再获得锁b的的顺序获得锁，而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。如下图所示

[19e7eabd3ee4487eb1917e011c76a55b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/11b262f788a14e159ac4a87a3397b609.png