C#高级进阶教程_12_异步和多线程（委托的异步使用）

字数统计: 3.9k字   |   阅读时长≈ 16分

1、进程-线程-多线程，同步和异步的概念

我们生活中有许许多多关于进程与线程的小例子，比如：1.我们使用打开一个微信软件，这个时候就开启了一个进程，当我们在微信里面进行各种操作（查看朋友圈，扫一扫…），这么多的操作就是线程。

所以我们可以说”进程”是包含”线程”的，”线程”是”进程”的一个子集。

进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。

程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

** 线程（thread）**是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

简单总结一下：

**
**

进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。

线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。（程序执行流的最小单位）

**
**

进程与线程的理解：

1.计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。

2.假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。

3.进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

4.一个车间里，可以有很多工人。他们协同完成一个任务。

5.线程就好比车间里的工人。一个进程可以包括多个线程。

6.车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。

7.可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。

8.一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫“互斥锁”（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。

9.还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。

10.这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做“信号量”（Semaphore），用来保证多个线程不会互相冲突。

不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

11.

操作系统的设计，因此可以归结为三点：
（1）以多进程形式，允许多个任务同时运行；
（2）以多线程形式，允许单个任务分成不同的部分运行；
（3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

计算机的概念

01、进程与线程

进程和线程是计算机的概念。

进程：一个程序运行时，占用的所有计算资源的总和。

线程：程序执行流的最小单位；任何操作都是由线程完成的；

线程依托于进程存在的，一个进程可以包含多个线程；

线程也可以有自己的计算资源。

02、多线程

1. 多个执行流同时进行。

CPU太快了，分时间片。（上下文切换）

微观角度，一个核同一时刻只能执行一个线程；宏观角度，多线程并发执行。

2.多CPU多核 可以独立工作，并发进行。

6核12线程（6个物理核，12个虚拟核。这里的“线程”代表的是虚拟核）

3.Tread类是C#语言对线程对象的封装。

计算机方面的多线程和开发Tread，Task、TreadPool、Parallel中的多线程不完全一样。

并发执行机制原理：

简单地说就是把一个处理器划分为若干个短的时间片，每个时间片依次轮流地执行处理各个应用程序，由于一个时间片很短，相对于一个应用程序来说，就好像是处理器在为自己单独服务一样，从而达到多个应用程序在同时进行的效果。

03、同步/异步

同步/异步是对方法执行的描述。

同步：完成计算后，再进入下一行。按顺序执行。

异步：不会等待方法的完成，会直接进入下一行。无需等待执行。非阻塞。

1
2
action.Invoke(name);
action.BeginInvoke(name, null, null);

04、异步、多线程

认识：C#异步、多线程。多线程就是多个Tread并发；C#语言里面的东西。

线程是源于操作系统的。

理解：同步方法卡界面（主UI线程，忙于计算）

异步多线程方法不卡界面，主线程完事儿了，计算任务交给子线程在做。

异步多线程作用

1、可以提升用户体验。(Winform，还可以使用主UI线程)

2、一个业务操作后发送邮件。（web开发，异步发送邮件。无需等待）异步+回调？异步多线程和Ajax区别？

3、速度快。用资源换时间（可能出现资源不够的情况）

4、多线程有管理成本。

5、多个独立任务可以同时进行的情况下，才有使用价值！

6、启动无序、执行时间不确定。结束也无序。

注意：尽量避免通过等几毫秒的形式来控制启动/执行时间/结束。//Tread.Sleep(5); 顺序控制不好控制！

回调 / 状态检测 / 状态等待 / 信号量？？

Action和Func 委托的异步调用

AsyncCallback 异步回调函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void btnAsyncAdvanced_Click(object sender, EventArgs e)
{
   Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
   Action<string> action = this.DoSomethingLong;
   IAsyncResult asyncResult0 = null;
   AsyncCallback callback = ia => //传入ia参数，执行下面的方法体
   {
       Console.WriteLine(object.ReferenceEquals(asyncResult0, ia));//Reference引用
       Console.WriteLine(ia.AsyncState);
       Console.WriteLine($"到这里计算已经完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。");
   };
  asyncResult0 = action.BeginInvoke("btnAsyncAdvanced_Click", callback, "hao");//回调函数，此方法调用完之后，才会调用回调函数。
  
  Console.WriteLine($"到这里计算已经完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
private void btnAsyncAdvanced_Click(object sender, EventArgs e)
{
    Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("0000000")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
    Action<string> action = this.DoSomethingLong;
    IAsyncResult asyncResult0 = null;

    AsyncCallback callback = ia =>//回调函数
    {
        Console.WriteLine(object.ReferenceEquals(asyncResult0, ia));
        Console.WriteLine(ia.AsyncState);
        Console.WriteLine($"到这里计算已经完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。");
    };
    asyncResult0 = action.BeginInvoke("btnAsyncAdvanced_Click", callback, "hao");//委托Action的异步调用
  
    int i = 0;
    while (!asyncResult0.IsCompleted)//1 卡界面：主线程忙于等待
    {   //可以等待，边等待边做其他操作
        //可能最多200ms的延迟
        if (i < 10)
        {
            Console.WriteLine($"文件上传完成{i++ * 10}%..");//File.ReadSize
        }
        else
        {
            Console.WriteLine($"文件上传完成99.9%..");
        }
        Thread.Sleep(200);//等待200毫秒
    }
    Console.WriteLine($"上传成功了。。。..");
}

![IMAGE](resources/8D23A3B21044A753826A7426C65D5ECC.png =1440x365)

1
2
3
asyncResult0.AsyncWaitHandle.WaitOne();//等待任务的完成，及时等待
asyncResult0.AsyncWaitHandle.WaitOne(-1);//等待任务的完成
asyncResult0.AsyncWaitHandle.WaitOne(1000);//限时等待；但是最多等待1000ms
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
action.EndInvoke(asyncResult0);//可以等待
{
  Func<int> func = () =>
    {
        Thread.Sleep(2000);
        return DateTime.Now.Day;//带返回值的委托Func
    };
  Console.WriteLine($"func.Invoke()={func.Invoke()}");//可以拿到计算结果unc.Invoke();

  IAsyncResult asyncResult = func.BeginInvoke(r => //r为回调函数
   {
       func.EndInvoke(r);
       Console.WriteLine(r.AsyncState);
   }, "打印LJK");

  Console.WriteLine($"func.EndInvoke(asyncResult)={func.EndInvoke(asyncResult)}");//func.EndInvoke(asyncResult)
}

Console.WriteLine($"全部计算真的都完成了，然后给用户返回{Thread.CurrentThread.ManagedThreadId.ToString("00")}");
Console.WriteLine($"****************btnAsyncAdvanced_Click End   {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private void btnAsyncAdvanced_Click(object sender, EventArgs e)
        {
            Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("0000000")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
            Action<string> action = this.DoSomethingLong;
            
            Thread.Sleep(200);
            Console.WriteLine("Do Something Else......");
            Console.WriteLine("Do Something Else......");
            Console.WriteLine("Do Something Else......");

            {
                Func<int> func = () =>
                  {
                      Thread.Sleep(2000);
                      return DateTime.Now.Year;
                  };
                Console.WriteLine($"func.Invoke()={func.Invoke()}");

                IAsyncResult asyncResult = func.BeginInvoke(r =>
                 {
                    //func.EndInvoke(r);
                     Console.WriteLine($"________func.EndInvoke(asyncResult)={func.EndInvoke(r)}\n");//func.EndInvoke(r)；结果为2021。
                     Console.WriteLine("________" + r.AsyncState + "状态\n");
                     Console.WriteLine("________");
                 }, "ljk");

               //Console.WriteLine($"func.EndInvoke(asyncResult)={func.EndInvoke(asyncResult)}");//可以拿到结果值
            }

            Console.WriteLine($"全部计算真的都完成了，然后给用户返回{Thread.CurrentThread.ManagedThreadId.ToString("000000")}");
            Console.WriteLine($"****************btnAsyncAdvanced_Click End   {Thread.CurrentThread.ManagedThreadId.ToString("000000")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
        }

![IMAGE](resources/7A1C7A4EA248C639D2051E728AF58B1E.png =1098x343)

附：如何将类封装起来，提供成一个dll？

多线程

Tread、TreadPool、Task、Parallel

1、Tread 线程

.Net 1.0 时代

01、线程的开启、挂起、唤醒、销毁、取消销毁

1
2
3
4
5
6
7
Action action = () => this.DoSomethingLong("btnThreads_Click");//无参数无返回值的委托
ThreadStart threadStart = () => this.DoSomethingLong("btnThreads_Click");//ThreadStart类似于Action，但又不同
//Thread thread = new Thread(action);//这个是错的，虽然类型样式一样，但类型是不同的
Thread thread = new Thread(threadStart);
thread.Start();
thread.Suspend();//线程挂起（已被放弃，容易导致死锁）资源的占用
thread.Resume(); //唤醒（已被放弃，容易导致死锁）
1
2
3
4
5
6
7
8
try
{
    thread.Abort();//销毁，方式是抛异常。也不建议（不一定及时/有些动作发出收不回来）
}
catch (Exception)
{
    Thread.ResetAbort();//取消Abort异常
}

02、线程等待

1
2
3
4
//线程等待
thread.Join(500);//最多等500，Join可以重载。
Console.WriteLine("等待500ms");
thread.Join();//当前线程等待thread完成
1
2
3
4
while (thread.ThreadState != ThreadState.Stopped)
{
  Thread.Sleep(100);//当前线程 休息100ms
}

03、前台线程和后台线程

1
2
Console.WriteLine(thread.IsBackground);//默认是flase。 前台线程，启动之后一定要完成任务的，阻止进程退出。
thread.IsBackground = true;//指定后台线程：随着进程退

04、线程的优先级

1
thread.Priority = ThreadPriority.Highest;//线程优先级 CPU优先执行Highest

2、ThreadPool 线程池

.Net 2.0 时代

线程池——享元模式——数据库连接池

01、Thread提供了太多的API，大部分意义不大。容易误伤… …

02、会无限使用线程，加以限制。

03、重用线程，避免重复的创建和销毁！准备容器Pool，减少创建和销毁的开销。

01、线程池启动多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Console.WriteLine($"****************btnThreadPool_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
Thread.Sleep(10 * 1000);
Console.WriteLine("前面的计算都完成了。。。。。。。。");

ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));

02、线程池的最大线程数、最小线程数

1
2
ThreadPool.SetMaxThreads(16, 16);
ThreadPool.SetMinThreads(8, 8);
1
2
3
4
5
6
7
8
{
  ThreadPool.GetMaxThreads(out int workerThreads, out int completionPortThreads);
  Console.WriteLine($"GetMaxThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
}
{
  ThreadPool.GetMinThreads(out int workerThreads, out int completionPortThreads);
  Console.WriteLine($"GetMinThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
}

03、ThreadPool 线程等待

ManualResetEvent 手动重置事件。其他Api基本取消了。

1
2
3
4
5
6
7
8
9
10
11
//类  包含了一个bool属性
//false--WaitOne等待--Set--true--WaitOne直接过去
//true--WaitOne直接过去--ReSet--false--WaitOne等待
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(t =>
{
    this.DoSomethingLong("btnThreadPool_Click");
    manualResetEvent.Set();
    //manualResetEvent.Reset();
});
manualResetEvent.WaitOne();

但是一般来说，不要阻塞线程池的线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
for (int i = 0; i < 20; i++)
{
  int k = i;
  ThreadPool.QueueUserWorkItem(t =>   //开启线程池
  {
    Console.WriteLine(k);//用i会报错
    if (k < 18)
    {
      //manualResetEvent.Reset();//设置为false
      manualResetEvent.WaitOne();//设置为false
    }
    else
    {
        manualResetEvent.Set();
    }
  });
}
if (manualResetEvent.WaitOne())
{
  Console.WriteLine("没有死锁、、、");
}

04、线程池的重用

1
2
3
4
5
6
7
8
9
10
11
12
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
Thread.Sleep(10 * 1000);
Console.WriteLine("前面的计算都完成了。。。。。。。。");
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
1
2
3
4
5
6
7
8
9
10
11
private void DoSomethingLong(string name)
{
    Console.WriteLine($"****************DoSomethingLong {name} Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
    long lResult = 0;
    for (int i = 0; i < 1000000000; i++)
    {
        lResult += i;
    }
    //Thread.Sleep(2000);
    Console.WriteLine($"****************DoSomethingLong {name}   End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************");
}

![IMAGE](resources/CB9A1F9BF5EC5814354988EB340CAFDE.png =1376x411)

05、线程的回调

**
**

** 基于Thread线程的回调**

1
2
3
4
5
6
7
8
9
10
//启动子线程计算--完成委托后，该线程去执行后续回调委托
private void ThreadWithCallback(Action act, Action callback)
{
  Thread thread = new Thread(() =>
  {
      act.Invoke();
      callback.Invoke();//和委托的异步调用一样的
  });
  thread.Start();
}
1
2
3
this.ThreadWithCallback(() => Console.WriteLine($"这里是action  {Thread.CurrentThread.ManagedThreadId.ToString("000")}"),
                        () => Console.WriteLine($"这里是callback  {Thread.CurrentThread.ManagedThreadId.ToString("000")}"));
Console.WriteLine("这里是主线程！！");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//带返回的异步调用,需要获取返回值。
private Func<T> ThreadWithReturn<T>(Func<T> func)
{
  T t = default(T); // default关键字？?
  Thread thread = new Thread(() =>
  {
    t = func.Invoke();
  });
  thread.Start();
  return () =>
  {
    thread.Join();
    return t;
  };
}
1
2
3
4
5
6
7
8
9
Func<int> func = this.ThreadWithReturn<int>(() =>
{
    Thread.Sleep(2000);
    return DateTime.Now.Year;
});

Console.WriteLine("这里是主线程！！");
int iResult = func.Invoke();
Console.WriteLine(iResult);

![IMAGE](resources/EA398D4B7796B6DB35E9050768E64CC7.png =975x106)

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家