最近在编程总是会遇到async, Mutex等字眼，今天来盘点以下同步和异步,顺便复习以下操作系统

进程(Process)

正在运行的程序。人们写的程序只定义了入口函数(比如__main_, main(), __main__)。如果执行这个程序，操作系统会为这个程序生成进程。比如在linux中，内核会从0号进程fork()出一个新的进程，接着把我们的代码装载进这个进程，最后这个进程从入口函数开始一步步运行。进程具有一定的资源，比如虚拟内存空间，正在执行程序文件。进程具有一定的标志，比如权限，调度优先级，进程运行状态。

线程(Thread)

考虑到进程的创建和销毁需要维护大量的数据结构(进程表)，再加上随着科技的发展，多核cpu逐渐称为主流，为了充分利用多核，人们创造了更小的单位:线程。多个线程能够共享同一个进程的资源。貌似linux在某个版本之后的调度算法将cpu的最小调度单元改成了线程，从而增加了对多核的支持。

协程(Coroutine)

比线程更小的单位。协程的调度并不需要系统调用，而是在一个线程内部实现。相当于一个用户态的的操作系统，但是基本的io操作依赖于线程的io系统调用。主要用来解决io密集线程过多的问题。比如1亿个线程的io读写，那么有很多的时间耗费在了线程切换之上(线程也有数据结构，只是比进程简单, 而且线程的切换是系统调用)。因此人们干脆把调度算法写在线程中，在线程调度协程，那么就只有一个线程，1亿个协程。时间虽然都花在了协程的切换之上，但由于协程的数据结构更简单，且不用频繁系统调用，耗时也减少了。

互斥

资源有限而需求无限。A和B都想买车票，一个售票口只能排队。假如A在B前面，B只能进入等待。

同步(sync)

B在A之后才能执行。

1. 上面互斥的例子，B只能等待A完成也是一种同步。
2. 生产者和消费者和商店。消费者到商店购买产品，没有产品只能等生产者造出产品送到商店才行。同步能让消费者进入等待。

异步(async)

B在A之后执行，不过B可以忙别的事。

1. 上面互斥的例子，B可以刷刷抖音，或者视线排队在边上坐着。等待A的通知，或者售票员喇叭的通知。
2. 上面同步的第二个例子i，消费者可以刷刷抖音或者在家里躺着。等待生产者的通知，或者商店的短信。

异步的实现

1. 创建(spawn)一个线程等待资源，主线程干别的事。
2. 线程获取资源后通过回调函数执行下一步，或者通过消息队列通知主线程。

简化异步

这个困惑了我很久，如今网上的热词如异步线程, 阻塞队列，天生并发等等等其实都是说的一件事: 简化异步。众所周知，操作系统已经帮我们实现了线程间异步。以linux为例, 线程天生就有就绪, 等待, 运行三个状态,并且内核也维护了一个阻塞队列。如果从头实现异步，我们需要

• 创建自己的消息队列
• 时不时自己管理线程
• 甚至维护自己的线程池

而这些所谓的高并发语言, 都维护了一个自己的阻塞队列，维护了自己的消息队列，维护了自己的线程池，维护了自己的并发io库,并且拥有自己的异步语法糖。

简化异步的编程范式

以nodejs为例分析简化异步写法的历史与发展，其他的大同小异。

• 回调函数时期。为了支持异步，于是将IO进行封装，尾巴带了一个回调函数

    // 同步IO函数
    function trueIO(): ResultType {
        ...
        return res;
    }
  
    // 将IO操作和trueIO装入一个线程，并加入阻塞队列
    // 从而不会阻止主线程
    function trueIOAsync(callback: (result: ResultType) => void) {
        block_queue.add(function () {
            const res = trueIO();
            callback(trueIO);
        })
    }
  
    // 没有实现阻塞队列的语言可能会用spawn
    function trueIOAsync(callback: (result: ResultType) => void) {
        spawn(function () {
            const res = trueIO();
            callback(trueIO);
        })
    }
  
    // 调用异步IO函数
    trueIOAsync(function (res) {
        console.log(res);
    })
  

  注:这个trueIO和block_queue.add是我假设的函数

• Promise时期。后来有人觉得回调函数不太优雅，加上动态语言，函数式思想，builder模式，链式调用的流行，就改变了封装方法，Promise应运而生

  class Promise {
      callback: ((value: any) => void)[];
  
      new(fn: ((result: ResultType) => void, r(err: ErrType) => void) => void) {
         fn(this.innerResolve);
      }
  
      then<T>(fn: (value: T) => void) {
          this.callback.push(fn);
          return this;
      }
  
      innerResolve(result) {
          this.callback.forEach(fn => fn(result));
      }
  }
  

  这样就能够统一管理回调函数，于是可以把回调函数封装成链式调用

   // 封装异步IO函数,加入阻塞队列
   function trueIOPromise() {
       return new Promise(function (res) {
       block_queue.add(function () {
           const res = trueIO();
           res(res);
       });
   })
  
   // 调用异步IO函数
   trueIOPromise().then((res) {console.log(res) });
   }
  

  上面是比较底层的Promise，我们也可以画蛇添足通过异步回调函数构造Promise

  function trueIOPromise() {
      return new Promise(function (res) {
          trueIOAsync(res(res));
      });
  }
  

• async, await。有人觉得new Promise(...)依旧不够优雅，因此出现了async和await。

  // 借用上面的trueIOPromise()
  async asyncFn() {
      return await trueIOPromise();
  }
  
  // 经过转译后
  function asyncFn() {
      return trueIOPromise();
  }
  
  
  // 第二个例子
  async asyncFn() {
      res = await trueIOPromise();
      res++;
      return res;
  }
  
  // 经过转译后
  function asyncFn() {
      return new Promise(function (resolve) {
          let res = undefined;
          trueIOPromise().then(function (result) {
             res = result;
             res++;
             resolve(res);
          })
      })
  }
  

以上就是三个阶段。至于基于强大过程宏的rust的future, invoke也是大同小异