概述：本文讨论了程序设计领域的同步、异步和多线程的一些基本概念。

同步异步这两个词翻译的其实不通。我是不知道这两个词是啥意思。同步：步伐整齐；异步：步伐不整齐。大概这个意思，但是在编程设计领域啥意思？

国人的烦恼多来自于不明确的翻译所造成的后果。异步对应的英文是Asynchronous。这个词的含义是“非同时的”，在编程领域的含义则是指，线程之间的并发行为。所以异步代码就是多线程并发代码；同步是单线程代码。这样来理解同步异步就比较简单明了。

网上讲异步代码实现的很多。例如使用async/await来实现异步。却少有讨论其本质逻辑的文章。比如下面这个问题：同步代码需要等待耗时过程执行结束再继续执行。异步代码也要await。那么同步等待和异步等待有什么区别？为什么异步效率就高。实际上，其实这两个等待并没有区别，它们是一样的。而且如果异步并等待了，那效率就不高了。看例子。

请看下面的代码示意。

int async Func1()
{
    print("Func1 in.");
    sleep(10);
    print("Func1 out. 10 second");
    return 1;
}
int async Func2()
{
    print("Func2 in.");
    sleep(5);
    print("Func2 out. 5 second");
    return 2;
}

void main() 
{
    print("begin");
    let f1 = await Func1();
    let f2 = await Func2();
    print("end");
    return ;
}

main函数耗时15秒，Func1函数耗时10秒，Func2函数耗时5秒。main函数中虽然异步调用了两个耗时函数。但是与单线程的同步代码耗时是一样的。单线程顺序调用两个函数耗时也将是15秒。

执行结果如下：

begin
Func1 in.
Func1 out. 10 second
Func2 in.
Func2 out. 5 second
end

现在，将main函数换种写法

void main() 
{
    print("begin");
    let f1 =  Func1();
    let f2 =  Func2();
    let r1 = await f1;
    let r2 = await f2;
    print("end");
    return ;
}

此时，main函数总耗时10秒，节省了5秒钟，输出结果：

begin
Func1 in.
Func2 in.
Func2 out. 5 second
Func1 out. 10 second
end

从输出结果来看，Func1和Func2实现了并发执行。同时开始，分别结束。耗时短的Func2开始的稍晚，但是率先执行完成了。并行执行的结果就是在最耗时的函数执行结束后，main函数也执行结束。main函数执行时间等于耗时最长函数的执行时间。

两种main函数的区别是异步函数Func的调用和等待，由一行代码实现，改为分两行代码实现。为什么多了个换行，就实现了并发？ 这其实不是分行的威力。我们来仔细分析一下语义。

• 第一种一行实现调用等待的写法的实际含义是。异步调用Func1，并立即等待。等待Func1执行结束之后（此时已过去了10秒），才异步调用Func2，并等待Func2执行结束。Func2结束后（此时又过去了5秒），main函数执行结束。这相当于，你指派了两个人分别去干两件事，但是要等第一个人出去办完事回来后，才指派第二个人出发。这就和指派一个人去办这两件事，需要的时间是相等的。所以这种异步调用和等待一行完成的写法，在形式上是异步的，但实际效果上等同与同步的、阻塞式的代码。为什么说它形式上又是异步的，因为它确实起了两个线程来分别执行Func1和Func2，它的确是多线程的。但两个线程由于要立即等待线程执行结果，所以是顺序执行，而不是并行执行。所以这种等待方式，就导致了效率降低。失去了异步的优势。
• 第二中写法，分为两行。先异步调用两个函数，再等待两个函数执行结果。则实现了函数的并发执行。相当于让两个人出去办事，两人同时出发。办完事回来报告结果。两件事情将会并行完成。效率有所提高。编程语言在这里我觉得早晚会优化一下，这个陷阱隐藏的比较深。语句写法的细微差别，效果却截然不同。

异步代码的本质是启动一个单独的线程去调用一个函数。而这样就带来了一个好处，就是调用方，有一个机会，可以选择等待、或者不等待函数的返回结果。 当调用方不关心函数的返回结果时，或者函数本身只是执行一些过程调用，不需要返回结果。或者执行结果，可以通过其他方式，比如消息机制，通知关心返回结果的对象。那么此时，调用方就可以只异步调用函数，而不必等待。看代码。

void main() 
{
    print("begin");
    let f1 =  Func1();
    let f2 =  Func2();
    print("end");
    readkey()
    return ;
}

执行结果

begin
Func1 in.
Func2 in.
end
Func2 out. 5 second
Func1 out. 10 second

main函数，会立即执行到输出end的位置。而后，两个函数继续执行耗时的操作。本文的例子只考虑main函数，输出“begin”开始，到输出“end"为止的响应时间。上面例子的readkey（）一句是为了保证Func1和Func2执行完成，这不在本文讨论范围之内，可以无视。main函数对耗时函数Func1 Func2的调用是即时响应的。几乎没有消耗时间。不需要等待耗时的函数执行完成。实现了程序的快速响应。不等待，才最大地发挥了异步代码的优势。

下面举一个形象的例子来说明。假如你是一个公司的CEO（你的真实身份其实是CPU）。

• 第一方式，你每天到公司，把自己关在办公室里，把工作一件接一件的顺序完成。这就是单线程阻塞式工作方式，就是同步代码的工作方式。
• 第二种方式，你到公司后，把每件工作交给一个员工去做，并等待他们完成工作后汇报结果。这相当于异步调用+等待模式的工作方式。这个属于异步代码，但是仍然是阻塞式的。即你还被阻塞在办公室。
• 第三种，你到公司后，把工作分配给员工，然后马上离开办公室，回家烤鸡翅。并让员工在工作完成后，发短信通知你。这个就是非阻塞式的异步代码工作方式了，即异步不等待。

还有一个误区值得说一下。就是认为每多开辟一个线程，程序就会多得到一倍的计算能力。如果是这样的话，那开辟1000个线程，pc岂不是变成了超级计算机。不是这样的，一个程序由单线程，变为两个线程执行时，这两个线程的每个线程的计算能力就变成了原来单线程的1/2，两个线程计算能力的总和等于原来单线程的计算能力。如果，分为10个线程，每个线程的计算能力就是原来的1/10。

多线程的计算能力的总和是不变的，等于cpu的计算能力。

然而，即使是1/10的算力，也远大于完成线程任务所需要的计算能力。所以10个线程可以同时执行。完成10个任务的需要的时间，等于完成一个任务的时间。总时间缩短为1/10。所以，多线程执行的任务，都应该是不需要太多cpu时间的任务。都是例如写磁盘，网络访问这样的慢速任务，cpu始终在等待这些慢速设备的响应。因为磁盘、网络这些设备的速度比cpu要慢成百上千倍。而如果是很消耗cpu的任务，例如大文件压缩。则，分多任务去执行，并不会有太大效果。所需要的时间是一样的。

比如孙悟空分身，分10个身，那每个分身的个头都只是原来的1/10。让这10个小猴，去捡果子，一次就能拿回来10个果子。效率很高。但是如果是搬大石头的活，一个大猴如果搬不动，分成10个小猴，也依然是搬不动。或者说，一个大猴1分钟把巨石搬了一米，10个小猴，1分钟也只能把这块巨石搬一米。

搬石头这种任务中，多线程并不会提升性能。这里指的是单核多线程，而不是多核多线程。多核cpu的工作方式是一个核累死（占用率100%），其他核也是无动于衷的。你的应用程序如果支持多核多线程，那把这个选项打开，性能就会原地起飞。

一个8核cpu，就相当于是地上一个猴，树上还骑七个猴。只有地上这一个猴干活。树上的七个猴不干活。或者他们服务于其他应用，在为其他应用干活。但通常他们都是空闲的。如果你让他们参与到你的应用程序，性能就会加倍。

回到我们的主题。总而言之，异步就是多线程并发。同步就是单线程。