什么是多线程

基本概念

线程

• 被定义为程序的执行路径，也叫执行单元
• 线程是轻量级进程；使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率

进程

• 是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程
• 一个进程可以包括一个或多个线程， 注：至少得有一个线程
• 进程之间是相对独立的，一个进程无法访问另一个进程的数据

查看当前系统中的进程

打开任务管理器，查看当前运行的进程

编辑

查看当前系统中的线程

在任务管理器里面查询当前总共运行的线程数

编辑

并行与串行（异步与同步）

• 并行（异步）： 多个线程同时执行任务
  • 举例：小明在烧开水的同时去洗菜了
• 串行（同步）： 一个任务执行完后才能执行下一个
  • 举例：小明在烧开水，等开水烧开后再去洗菜

线程的生命周期

• 新建 ：当线程实例被创建但 Start 方法未被调用时的状况
• 就绪 ：当线程准备好运行并等待 CPU 调度
• 不可运行 ：下面的几种情况下线程是不可运行的：
  • 已经调用 Sleep 方法
  • 已经调用 Wait 方法
  • 通过 I/O 操作阻塞
• 死亡状态 ：当线程已完成执行或已中止时的状况

主线程

• 一个进程可以包含若干个线程，在进程入口执行的 第一个线程被视为这个进程的主线程 。
• 在 C# 中，都是以Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。
• 在 C# 中，System.Threading.Thread 类用于线程的工作。它允许创建并访问多线程应用程序中的单个线程
• 可以使用 Thread 类的 CurrentThread 属性访问线程。

举例：主线程执行

internal class ThreadTest
{
  static void Main(string[] args)
  {
    Thread th = Thread.CurrentThread;
    th.Name = "MainThread";
    Console.WriteLine("线程ID是：{0},线程名称是：{1}", th.ManagedThreadId, th.Name);
  }
}

输出结果

线程ID是：1,线程名称是：MainThread

**多线程的创建与管理 **

创建

• 线程是通过扩展 Thread 类创建的，然后在构造方法中传入委托对象。扩展的 Thread 类调用 Start() 方法来开始子线程的执行
• **子线程不需要传参使用 **ThreadStart

internal class ThreadTest
{
  static void Main(string[] args)
  {
    // 创建两个子线程
    Thread t1 = new Thread(new ThreadStart(PrintStr));
    Thread t2 = new Thread(new ThreadStart(PrintStr));
    t1.Start();
    t2.Start();
  }


  private static void PrintStr()
  {
    Thread th = Thread.CurrentThread;
    Console.WriteLine("线程ID是：{0}", th.ManagedThreadId);
  }
}

输出结果

线程ID是：7
线程ID是：6

通过ThreadStart 源码，可以看到它其实是一个委托

编辑

• 如果要向子线程中传递参数则需要使用： ParameterizedThreadStart
• 注意：ParameterizedThreadStart委托的参数类型必须是Object的

internal class ThreadTest
{
  static void Main(string[] args)
  {
    // 创建两个子线程
    Thread t1 = new Thread(new ParameterizedThreadStart(PrintStrParam));
    Thread t2 = new Thread(new ParameterizedThreadStart(PrintStrParam));
    t1.Start("我是有参数1");
    t2.Start("我是有参数2");
  }


  private static void PrintStrParam(Object obj)
  {
    Thread th = Thread.CurrentThread;
    Console.WriteLine("线程ID是：{0},参数是：{1}", th.ManagedThreadId,obj);
  }
}

输出结果

线程ID是：6,参数是：我是有参数1
线程ID是：7,参数是：我是有参数2

线程的管理与销毁

• Thread 类提供了各种管理线程的方法，下面演示sleep() 方法的使用，用于在一个特定的时间暂停线程
• Abort() 方法用于销毁线程；通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。 注：这个方法被标记过时了，虽然依旧可以使用，但推荐使用 CancellationToken 来代替

internal class ThreadTest
{
  static void Main(string[] args)
  {
    // 创建两个子线程
    Thread t1 = new Thread(new ThreadStart(printSleep));
    t1.Start();
    // 主线程睡眠 1 秒
    Thread.Sleep(1000);


    // 销毁线程
    try
    {
      t1.Abort();
    }
    catch (ThreadAbortException e)
    {
      Console.WriteLine("进catch了吗？？？");
    }
    finally
    {
      Console.WriteLine("进finally了吗？？？");
    }
  }


  private static void printSleep()
  {
    for (int i = 0; i < 10; i++)
    {
      // 睡眠 500 毫秒
      Thread.Sleep(500);
      Console.WriteLine("输出数字:{0}", i);
    }
  }
}

输出结果

输出数字:0
Unhandled exception. 输出数字:1
System.PlatformNotSupportedException: Thread abort is not supported on this platform.
输出数字:2
进finally了吗？？？

线程同步与锁

• 所谓同步：是指在某一时刻只有一个线程可以访问变量。
• 如果不能确保对变量的访问是同步的，就会产生错误。比如：两个人同时卖一个仓库中的同种 手机，如果不控制就可能出现 超卖现象 （即卖出的大于库存的）
• c#为同步访问变量提供了一个非常简单的方式，即使用c#语言的关键字 **Lock**，它可以把一段代码定义为互斥段，互斥段在一个时刻内只允许一个线程进入执行

lock块语法：

• 需要注意，传给**lock块**的参数不能是值类型和string类型，必须是除了string外的引用类型，而且这个引用类型对象必须是所有线程都能访问到的，否则锁不住。
• 如果你想保护一个类的实例，一般地，你可以使用this；
• 如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了
• 也可以单独创建一个object对象来作为指定的锁对象

语法如下：

lock(expression)
{
   // 代码逻辑
}

加锁前案例

internal class ThreadTest
{
  static void Main(string[] args)
  {
    PhoneSale phone=new PhoneSale();


    // 创建两个子线程
    Thread t1 = new Thread(new ThreadStart(phone.SalePhone));
    Thread t2 = new Thread(new ThreadStart(phone.SalePhone));
    t1.Start();
    t2.Start();
  }


}


public class PhoneSale
{
  // 数量
  private int num = 1;


  public void SalePhone()
  {
    if (num > 0)
    {
      Thread.Sleep(100);
      num--;
      Console.WriteLine("卖出一部手机,还剩下 {0} 个",num);
    }
    else
    {
      Console.WriteLine("卖完了....");
    }
  }
}

输出结果

卖出一部手机,还剩下 0 个
卖出一部手机,还剩下 -1 个

**加锁后案例

**

internal class ThreadTest
{
  static void Main(string[] args)
  {
    PhoneSale phone=new PhoneSale();


    // 创建两个子线程
    Thread t1 = new Thread(new ThreadStart(phone.SalePhone));
    Thread t2 = new Thread(new ThreadStart(phone.SalePhone));
    t1.Start();
    t2.Start();
  }


}


public class PhoneSale
{
  // 数量
  private int num = 1;


  public void SalePhone()
  {
    lock (this)
    {
      if (num > 0)
      {
        Thread.Sleep(100);
        num--;
        Console.WriteLine("卖出一部手机,还剩下 {0} 个", num);
      }
      else
      {
        Console.WriteLine("卖完了....");
      }
    }
  }
}

输出结果

卖出一部手机,还剩下 0 个
卖完了....

多线程的优缺点

优点

• 可以同时完成多个任务，使程序的响应速度更快
• 多线程技术解决了多部分代码同时执行的需求，能够更好的利用cpu的资源
• 可以设置每个任务的优先级以优化程序性能

缺点

• 线程需要占用内存，线程越多，占用内存也越多
• 多线程需要协调和管理，所以需要占用CPU时间以便跟踪线程
• 线程之间对共享资源的访问会相互影响，必须解决争用共享资源的问题
• 线程太多会导致控制太复杂

为什么程序可以多线程执行呢？ 程序中的多线程与CPU的多线程有什么关系？

• 目前电脑都是多核多CPU的，一个CPU在同一时刻只能运行一个线程，但是多个CPU在同一时刻就可以运行多个线程。

• 线程的最大并行数量上限是CPU核心的数量，但是，往往电脑运行的线程的数量远大于CPU核心的数量，所以　还是需要CPU时间片的切换

• CPU运行速度太快，硬件处理速度跟不上，所以操作系统进行分 ** 时间片

  管理** 。这样，从宏观角度来说是多线程并发的，因为CPU速度太快，察觉不到，看起来是同一时刻执行了不同的操作