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

C#多线程学习总结

news 来源：原创 2024/5/20 13:04:14

在这里插入图片描述
线程的基础概念
操作系统能够优先访问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的顺序获得锁。如下图所示