C# 多线程（1）——线程基础

contact97

已于 2024-03-05 10:24:29 修改

阅读量1.2k

点赞数 13

分类专栏： .Net 并发文章标签： c# 多线程

于 2023-11-28 15:43:21 首次发布

本文链接：https://blog.csdn.net/contact97/article/details/134663671

版权

.Net 同时被 2 个专栏收录

15 篇文章 3 订阅

订阅专栏

并发

6 篇文章 0 订阅

订阅专栏

进程是计算机概念，一个程序运用时占用的的所有计算机资源（CPU、内存、硬盘、网络）统称为进程。
线程是操作系统中能够独立运行的最小单位，是进程（包含多个线程）中的一部分，线程也有自己的计算资源，多个线程间可以共享进程的资源
C#中的Thread其实是对计算机中线程概念的封装（API的封装），它的执行归根结底是向底层操作系统申请了线程资源。

在C#中的线程实现包括 Thread/ThreadPool/Task/Await Async
多线程的本质是资源换性能（CPU、内存、硬盘、网络）。好处是提高利用率（快）坏处是耗费资源。但是在使用N个线程时，性能并不是成N倍的递增。
因为操作系统对CPU的调度时必须耗费些许时间，包括CPU的分片，线程的调度以及上下文的切换。同时CPU不够时降低线程的性能，这也意味着不是线程越多越好。

以下代码示例默认引用了System.Threading命名空间

2 创建线程

线程创建可以不通过显示的调用ThreadStart和ParameterizedThreadStart,主要是通过lamda表达式去创建线程

 static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            //public Thread(ThreadStart start) ThreadStart 一个无参数的委托
            Thread t1 = new Thread(() =>
            {
                Console.WriteLine("一个无参数的的线程创建");
            });
            t1.Start();

            //Thread(ParameterizedThreadStart start) ParameterizedThreadStart 一个有参数的委托
            //lambda 表达式是向线程传递数据的最强大的方法。然而必须小心，不要在启动线程之后误修改被捕获变量（captured variables）.解决方法就是使用临时变量
            Thread t2 = new Thread((x) =>
            {
                Console.WriteLine("一个有参数的的线程创建{0}", x);
            });
            //传入参数
            t2.Start(100);

        }

3 线程等待

可以使用 Join()方法来等待其他线程完成任务

  public   class ThreadWork
    {
        public void Method1() {
            Console.OutputEncoding = Encoding.UTF8;
            Console.WriteLine("当前线程名称" + Thread.CurrentThread.Name);
            for (int i = 0; i < 10; i++) {
                Thread.Sleep(1000);//线程暂停
                Console.WriteLine(i);
            }
        }
   }     

public class Program{
  static void Main(string[] args)
        {
            ThreadWork work = new ThreadWork();
            Thread t = new Thread(work.Method1);
            t.Start();
            t.Join();//主线程等待子线程完成任务
            Console.WriteLine("Finish");
        }
}

4 线程优先级

线程的Priority属性决定了相对于操作系统中的其它活动线程，它可以获得多少执行时间。线程优先级的取值如下：
enum ThreadPriority { Lowest, BelowNormal, Normal, AboveNormal, Highest } 。只有当多个线程同时活动时，线程优先级才有意义。默认创建的线程优先级别为Normal

  public   class ThreadWork
    {
        public void Method1() {
            Console.OutputEncoding = Encoding.UTF8;
            Console.WriteLine("当前线程名称" + Thread.CurrentThread.Name);
            for (int i = 0; i < 10; i++) {
                Thread.Sleep(1000);//线程暂停
                Console.WriteLine(i);
            }
        }
    }

      static void Main(string[] args)
        {
            ThreadWork work = new ThreadWork();
            Thread t1 = new Thread(work.Method1) { Priority = ThreadPriority.Highest, Name = "t1" };
            Thread t2 = new Thread(work.Method1) { Priority = ThreadPriority.Normal, Name = "t2" };

            t2.Start(); //t1线程优先级别高于t2线程，将优先获得CPU的时间片，先执行
            t1.Start();
            Console.WriteLine("Finish");
        }

5 前台线程与后台线程

可以通过设置IsBackground来设定线程是否为后台线程。默认显示创建的线程都是前台线程。前台线程与后台线程最大的区别就是进程会等待所有的前台线程，当前台线程全部结束后，尽管后台线程的任务没有执行完，进程会自动结束所有存在的后台线程。所以当程式定义了一个永远不会完成的前台线程时，进程将永远不会结束。线程的前台/后台状态与它的优先级和执行时间的分配无关

  public   class ThreadWork
    {
        public void Method2(int num) {

            Console.OutputEncoding = Encoding.UTF8;
            for (int i = 0; i < num; i++)
            {
                Thread.Sleep(1000);//线程暂停
                Console.WriteLine("当前线程名称{0} 打印数据{1}",  Thread.CurrentThread.Name,i);

            }
        }
    }

       static void Main(string[] args)
        {
            ThreadWork work = new ThreadWork();
            Thread t1 = new Thread(() => work.Method2(5)) { Name = "t1" };
            Thread t2 = new Thread(() => work.Method2(10)) { Name = "t2", IsBackground = true };

            t1.Start();
            t2.Start(); // t1线程为前台线程(执行时间>10s) t2线程为后台线程（执行时间>5s） 前台线程结束后，会中断t2线程
            Console.WriteLine("Finish");
        }

6 Lock与线程安全

竞态：字面意思是竞争，并发的执行单元对共享资源（硬件资源和软件上的全局变量，静态变量等）的访问容易发生竞态，竞态是出现线程不安全的重要因素。
为了解决多线程并发抢夺共享资源的问题，可采用lock 关键字,lock会锁定最先抢到资源的线程，并且会阻塞(不占用CPU资源)其他试图抢夺该资源的其他线程，直到lock锁定的线程释放这个锁资源
这样就确保了在同一时刻只有一个线程能进入临界区（critical section，不允许并发执行的代码）像这种用来避免在多线程下的不确定性的方式被称为线程安全（thread-safe）
尽管lock关键字的存在会解决线程安全的问题，但是运用不恰当，存在严重的性能问题,因为上下切换上下文的时间可能会比单个线程执行还要慢。

   public  class CounterBase
    {
        //多线程共享这个变量，当存在读写操作时，会出现线程不安全的问题
        public int num { get; private set; }

        public CounterBase(int num)
        {
            this.num = num;
        }

        public void DecrementWithLock()
        {
            Console.WriteLine(Thread.CurrentThread.Name);
            //使用lock关键字，标识这段方法只允许一个线程持有
            lock (this) {
                num--;
            }
          
        }
        public void IncrementWithLock()
        {
            Console.WriteLine(Thread.CurrentThread.Name);
            lock (this)
            {
                num++;
            }

        }

        public void Count (){
            for (int i = 0; i < 10; i++)
            {
                IncrementWithLock();
                DecrementWithLock();
            }
        }

    }

 static void Main(string[] args)
        {
            CounterBase counter = new CounterBase(100);
            Thread t1 = new Thread(() => counter.Count()) { Name = "t1" }; // t1、t2 线程共享counter实例，并同时执行CountWhihLock()方法。意味着此时出现了竞态现象，容易出现线程不安全的问题 
            Thread t2 = new Thread(() => counter.Count()) { Name = "t2" };

            //多线程并行
            t1.Start();
            t2.Start();

            t1.Join();
            t2.Join();
            Console.WriteLine("Finish");
            Console.WriteLine(counter.num); //100

        }

7 Monitor

在Lock与线程安全这一section中，用到lock关键字来确保代码屏障区（用lock关键字包裹的代码区，同一时间，只有一个线程能进入到代码中）的安全执行。lock关键字Monitor类的的一个语法糖。可以通过TryEnter()进入锁 Monitor.Exit()进出锁。上述示例可以用Monitor类来重构功能

   public  class CounterBase
    {
        //多线程共享这个变量，当存在读写操作时，会出现线程不安全的问题
        public int num { get; private set; }

        public CounterBase(int num)
        {
            this.num = num;
        }

        public void DecrementWithLock()
        {
            Console.WriteLine(Thread.CurrentThread.Name);
            //使用Monitor替换lock关键字
            Monitor.TryEnter();
            num++；
            Monitor.Exit();

          
        }
        public void IncrementWithLock()
        {
            Console.WriteLine(Thread.CurrentThread.Name);
           //使用Monitor替换lock关键字
            Monitor.TryEnter();
            num--；
            Monitor.Exit();

        }

        public void Count (){
            for (int i = 0; i < 10; i++)
            {
                IncrementWithLock();
                DecrementWithLock();
            }
        }

    }

8 死锁

死锁是多个线程等待永远拿不到的锁资源时出现的程式异常问题。线程处于阻塞状态中。

    public class DeadLockWork
    {
        private readonly object _lock1 = new object();
        private readonly object _lock2 = new object();


        public void Method1() {
            lock (_lock1) {
                Console.WriteLine(Thread.CurrentThread.Name+" enterd Method1");
                Thread.Sleep(10);
                lock (_lock2) {
                }
            }
        }


        public void Method2()
        {
            lock (_lock2)
            {
                Console.WriteLine(Thread.CurrentThread.Name + " enterd Method2");
                Thread.Sleep(10);
                lock (_lock1)
                {
                }
            }
        }
  }

        static void Main(string[] args)
        {
            DeadLockWork deadLock = new DeadLockWork();
            // t1、t2 线程共享deadLock实例
            Thread t1 = new Thread(() => deadLock.Method1()) { Name = "t1" };
            Thread t2 = new Thread(() => deadLock.Method2()) { Name = "t2" };

            t1.Start();//t1线程进入方法后，持有_lock1锁，暂停10ms后尝试获取_lock2锁
            t2.Start();//t2线程进入方法后，持有_lock2锁，暂停10ms后尝试获取_lock1锁



            //主线程等待t1、t2线程完成任务
            t1.Join();
            t2.Join();

            //由于lock关键字会阻塞其他正在尝试获取锁的线程，t1持有lock1并尝试获取_lock2锁，t2持有lock2并尝试获取_lock1锁。
            //t1永远拿不到_lock2锁，t2永远拿不到_lock1锁。导致线程死锁。
            //进程等待两个前台线程执行完成，死锁导致程式永远不会结束
            Console.WriteLine("Finish");
        }

9 线程中异常处理

在实际项目中，每一个线程中应该有异常处理的逻辑，
因为每个线程都独享栈空间，主线程无法捕获其他工作线程中抛出的异常。未被捕获的异常可能会导致程式的异常中断。为了加强程式的健壮性，应该在工作任务中设计异常处理的逻辑

 static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            Thread t1 = new Thread(() =>
               {
                   try
                   {
                       Console.WriteLine("I am Thread " + Thread.CurrentThread.Name);
                       throw new Exception("模拟工作的中的异常：端口被占用");
                   }
                   catch (Exception e)
                   {
                      //捕获线程中的异常
                      Console.WriteLine(e.Message);
                   }

               })
            { Name = "t1" };

            t1.Start();
        }