目录
下面来思考这样一个问题：为什么程序计数器、虚拟机栈和本地方法栈是线程私有的呢？为什么堆和方法区是线程共享的呢？
一、什么是进程和线程
相信大家面试时一定没少被一个问题刁难，那就是进程和线程的区别是什么？这个问题延申开来并不像表面那么简单，今天就来深入一探。
开始前先看一组非常传神的图例，相信可以帮助你更好理解进程与线程的概念：
1.1 进程是什么呢？
进程是一个具有一定独立功能的程序在一个数据集合上依次动态执行的过程。进程是一个正在执行的程序的实例，包括程序计数器、寄存器和程序变量的当前值。进程是系统进行资源分配和调度的一个独立单位，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
直白地讲，进程就是应用程序的启动实例。比如我们运行一个游戏，打开一个软件，就是开启了一个进程。
进程拥有代码和打开的文件资源、数据资源、独立的内存空间。
如下图所示，在 Windows 中通过查看任务管理器的方式，我们就可以清楚看到 Windows 当前运行的进程（.exe 文件的运行）：
进程有哪些特征？
- 进程依赖于程序运行而存在，进程是动态的，程序是静态的；
- 进程是操作系统进行资源分配和调度的一个独立单位（CPU除外，线程是处理器任务调度和执行的基本单位）；
- 每个进程拥有独立的地址空间，地址空间包括代码区、数据区和堆栈区，进程之间的地址空间是隔离的，互不影响。
1.2 线程又是什么呢？
进程的创建、销毁与切换存在着较大的时空开销，因此人们急需一种轻型的进程技术来减少开销。在80年代，线程的概念开始出现，线程被设计成进程的一个执行路径，同一个进程中的线程共享进程的资源（共享进程的堆和方法区资源），因此系统对线程的调度所需的成本远远小于进程。
线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的执行单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（每个线程有自己的程序计数器、虚拟机栈和本地方法栈、一组寄存器），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
直白地讲，线程从属于进程，是程序的实际执行者。一个进程至少包含一个主线程，也可以有更多的子线程。线程拥有自己的栈空间。
Java 程序天生就是多线程程序，我们可以通过 JMX 来看看一个普通的 Java 程序有哪些线程，代码如下。
public class MultiThread {
public static void main(String[] args) {
// 获取 Java 线程管理 MXBean
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
// 遍历线程信息，仅打印线程 ID 和线程名称信息
for (ThreadInfo threadInfo : threadInfos) {
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
}
}
}上述程序输出如下（输出内容可能不同，不用太纠结下面每个线程的作用，只用知道 main 线程执行 main 方法即可）：
[5] Attach Listener //添加事件
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //调用对象 finalize 方法的线程
[2] Reference Handler //清除 reference 线程
[1] main //main 线程,程序入口
从上面的输出内容可以看出：一个 Java 程序的运行是 main 线程和多个其他线程同时运行。
1.3 线程和进程之间的关系
一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。
相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
操作系统、进程、线程之间的关系图：
进程与线程的模型图：
下面来思考这样一个问题：为什么程序计数器、虚拟机栈和本地方法栈是线程私有的呢？为什么堆和方法区是线程共享的呢？
程序计数器为什么是私有的?
程序计数器主要有下面两个作用：
- 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
- 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
需要注意的是，如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址，只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。
所以，程序计数器私有主要是为了线程切换后能恢复到正确的执行位置。
虚拟机栈和本地方法栈为什么是私有的?
- 虚拟机栈： 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
- 本地方法栈： 和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中本地方法栈与Java 虚拟机栈合二为一。
所以，为了保证线程中的局部变量不被别的线程访问到，虚拟机栈和本地方法栈是线程私有的。
堆和方法区为什么是共享的？
堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (几乎所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。为了所有线程都能够使用这些信息，所以堆和方法区是共享的。
理论过于抽象难解，下面还是用大家喜闻乐见的现实中的例子去类比，没错还是工厂的例子：
在计算机这个大工厂中，进程被比作一个车间，为生产活动提供了设计图、场地、生产线（线程）等生产要素，而线程是这个车间中的一条条生产线。生产线本身会有一个操作台，具体的零件在这里被生产。生产线必须由工人操作才能动起来，当工人来到一个生产线旁并启动它之前，必须查阅生产线的生产记录以便弄清楚这个生产线的零件加工到哪种程度了，然后才能准确地接续生产，当工人停止生产线前也必须记录这次的生产进度以备下次读取，这些进度信息可以理解为上下文，读取和记录生产进度的过程称为上下文切换。
一个工人可以在多条生产线间穿梭操作，就像CPU在不同线程间切换一样，这个动作被称为并发，与之对应的，多个工人操作多条生产线同时生产，称为并行。如果生产线不需要太多原料输入就能生产，那这种生产任务被称作CPU密集型，反之如果生产线大部分时间在等待原料的输入，那这种任务被称为IO密集型。显然，前者最好一条生产线由一个工人专管效率更高，而后一种任务，一个人在原料输入的间隙去操作其他生产线，无疑能提高工人利用率。
1.4 线程共享了进程哪些资源？线程是如何共享进程资源的？
线程是如何共享进程资源的？这个问题的答案其实很简单，就一句话：同一个进程内的线程共享其所属进程的地址空间，因此地址空间里有啥就共享啥。
面试官很可能继续问你能不能说具体点呢？接下来我们就来详细讲解一下这个问题。
1.4.1 逆向思考
查理芒格经常说这样一句话：“反过来想，总是反过来想”，如果你对线程之间共享了哪些进程资源这个问题想不清楚的话那么也可以反过来思考，那就是有哪些资源是线程私有的。
1.4.2 线程私有资源
线程运行的本质其实就是函数的执行，函数的执行总会有一个源头，这个源头就是所谓的入口函数，CPU从入口函数开始执行从而形成一个执行流，只不过我们人为的给执行流起一个名字，这个名字就叫线程。
既然线程运行的本质就是函数的执行，那么函数执行都有哪些信息呢？
函数运行时的信息保存在栈帧中，栈帧中保存了函数的返回值、调用其它函数的参数、该函数使用的局部变量以及该函数使用的寄存器信息，如图所示，假设函数A调用函数B：
此外，CPU执行指令的信息保存在一个叫做程序计数器的寄存器中，通过这个寄存器我们就知道接下来要执行哪一条指令。由于操作系统随时可以暂停线程的运行，因此我们保存以及恢复程序计数器中的值就能知道线程是从哪里暂停的以及该从哪里继续运行了。
由于线程运行的本质就是函数运行，函数运行时信息是保存在栈帧中的，因此每个线程都有自己独立的、私有的栈区。
同时函数运行时需要额外的寄存器来保存一些信息，像部分局部变量之类，这些寄存器也是线程私有的，一个线程不可能访问到另一个线程的这类寄存器信息。
从上面的讨论中我们知道，到目前为止，所属线程的栈区、程序计数器、栈指针以及函数运行使用的寄存器是线程私有的。
以上这些信息有一个统一的名字，就是线程上下文（thread context）。
我们也说过操作系统调度线程需要随时中断线程的运行并且需要线程被暂停后可以继续运行，操作系统之所以能实现这一点，依靠的就是线程上下文信息。
现在你应该知道哪些是线程私有的了吧。除此之外，剩下的都是线程间共享资源。那么剩下的还有什么呢？还有图中的这些：
这其实就是进程地址空间的样子，也就是说线程会共享进程地址空间中除线程上下文信息中的所有内容，意思就是说线程可以直接读取这些内容。
接下来我们分别来看一下这些区域（文件、堆区、代码区、数据区）。
1.4.3 代码区
进程地址空间中的代码区是线程都可以访问的区域，因为这个区域是只读的，多个线程使用是没有问题的，这里保存的是什么呢？从名字中有的同学可能已经猜到了，没错，这里保存的就是我们写的代码，更准确的是编译后的可执行机器指令。
那么这些机器指令又是从哪里来的呢？答案是从可执行文件中加载到内存的，可执行程序中的代码区就是用来初始化进程地址空间中的代码区的。
1.4.4 堆区
堆区是程序员比较熟悉的，我们在C/C++中用malloc或者new出来的数据就存放在这个区域，很显然，只要知道变量的地址，也就是指针，任何一个线程都可以访问指针指向的数据，因此堆区也是线程共享的属于进程的资源。
1.5 线程和进程之间有什么区别
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
- 本质区别：进程是操作系统资源分配的基本单位，而线程是CPU处理器任务调度和执行的基本单位。
- 包含关系：一个程序至少有一个进程，一个进程至少有一个线程，线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
- 资源开销：每个进程都有独立的地址空间，进程之间的切换会有较大的开销；线程可以看做轻量级的进程，同一个进程内的线程共享进程的地址空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换的开销小，从而极大地提高了程序的运行效率。
- 影响关系：一个进程崩溃后，在保护模式下其他进程不会被影响，但是一个线程崩溃可能导致整个进程被操作系统杀掉，所以多进程要比多线程健壮。
- 划分尺度：线程的划分尺度小于进程，使得多线程程序的并发性高。
- 执行区别：线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
- 逻辑角度：从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
- 如何协作：线程是通过共享内存来进行通信的。只有线程才能共享内存，进程是不可以的，因为进程所持有的资源都是独立的。
有人给出了很好的归纳：
- 线程是进程划分成的更小的运行单位。
- 线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
- 线程执行开销小，但不利于资源的管理和保护；而进程正相反。
- 对操作系统来说，线程是最小的执行单元，进程是最小的资源管理单元。
- 无论进程还是线程，都是由操作系统所管理的。
1.6 线程和进程的优缺点
线程和进程在使用上各有优缺点：
- 线程执行开销小，但不利于资源的管理和保护；而进程正相反。
- 同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。
注：对称多处理（Symmetrical Multi-Processing）简称SMP，是指在一个计算机上汇集了一组处理器(多CPU)，各CPU之间共享内存子系统以及总线结构。它是相对非对称多处理技术而言的、应用十分广泛的并行技术。
1.7 为什么要使用多线程?
先从总体上来说：
- 从计算机底层来说： 线程可以比作是轻量级的进程，是程序执行的最小单位，线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
- 从当代互联网发展趋势来说： 现在的系统动不动就要求百万级甚至千万级的并发量，而多线程的并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。
再深入到计算机底层来探讨：
- 单核时代： 在单核时代多线程主要是为了提高单进程利用 CPU 和 IO 系统的效率。 假设只运行了一个 Java 进程的情况，当我们请求 IO 的时候，如果 Java 进程中只有一个线程，此线程被 IO 阻塞则整个进程被阻塞。CPU 和 IO 设备只有一个在运行，那么可以简单地说系统整体效率只有 50%。当使用多线程的时候，一个线程被 IO 阻塞，其他线程还可以继续使用 CPU。从而提高了 Java 进程利用系统资源的整体效率。
- 多核时代: 多核时代多线程主要是为了提高进程利用多核 CPU 的能力。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，不论系统有几个 CPU 核心，都只会有一个 CPU 核心被利用到。而创建多个线程，这些线程可以被映射到底层多个 CPU 上执行，在任务中的多个线程没有资源竞争的情况下，任务执行的效率会有显著性的提高，约等于（单核时执行时间/CPU 核心数）。
1.8 使用多线程可能带来什么问题?
并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：内存泄漏、死锁、线程不安全等等。
二、什么是协程
2.1 协程
协程，英文Coroutines，是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。
最重要的是，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。
这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。
既然协程这么好，它到底是怎么来使用的呢？
由于Java的原生语法中并没有实现协程（某些开源框架实现了协程，但是很少被使用），所以我们来看一看python当中对协程的实现案例，同样以生产者消费者模式为例：
这段代码十分简单，即使没用过python的小伙伴应该也能基本看懂。
代码中创建了一个叫做consumer的协程，并且在主线程中生产数据，协程中消费数据。
其中 yield 是python当中的语法。当协程执行到yield关键字时，会暂停在那一行，等到主线程调用send方法发送了数据，协程才会接到数据继续执行。
但是，yield让协程暂停，和线程的阻塞是有本质区别的。协程的暂停完全由程序控制，线程的阻塞状态是由操作系统内核来进行切换。因此，协程的开销远远小于线程的开销 。
2.2 协程与线程的区别
协程不是进程或线程，其执行过程更类似于子例程，或者说不带返回值的函数调用。
一个程序可以包含多个协程，可以对比与一个进程包含多个线程，
因而下面我们来比较协程和线程。我们知道多个线程相对独立，有自己的上下文，切换受系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制，从当前协程切换到其他协程由当前协程来控制。
协程和线程区别：协程避免了无意义的调度，由此可以提高性能，但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多CPU的能力。
2.3 协程的特点在于是一个线程执行，那和多线程比，协程有何优势？
- 极高的执行效率：因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显；
- 不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
2.4 协程的应用
有哪些编程语言应用到了协程呢？我们举几个栗子：
1、Lua语言
Lua从5.0版本开始使用协程，通过扩展库coroutine来实现。
2、Python语言
正如刚才所写的代码示例，python可以通过 yield/send 的方式实现协程。在python 3.5以后，async/await 成为了更好的替代方案。
3、Go语言
Go语言对协程的实现非常强大而简洁，可以轻松创建成百上千个协程并发执行。
4、Java语言
如上文所说，Java语言并没有对协程的原生支持，但是某些开源框架模拟出了协程的功能，有兴趣的小伙伴可以看一看Kilim框架的源码。
三、线程、进程、协程的区别
- 进程拥有自己独立的堆和栈，既不共享堆，亦不共享栈，进程由操作系统调度（内核态）。
- 线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程亦由操作系统调度（内核态），至少标准线程是这样的。
- 协程和线程一样共享堆，不共享栈，协程由程序员在协程的代码里显示调度，也就是由程序自己来控制调度（用户态）。
一个应用程序一般对应一个进程，一个进程一般有一个主线程，还有若干个辅助线程，线程之间是平行运行的，在线程里面可以开启协程，让程序在特定的时间内运行。
协程和线程的区别是：协程避免了无意义的调度，由此可以提高性能，但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多CPU的能力。打个比方：
假设有一个操作系统，是单核的，系统上没有其他的程序需要运行，有两个线程 A 和 B ，A 和 B 在单独运行时都需要 10 秒来完成自己的任务，而且任务都是运算操作，A B 之间也没有竞争和共享数据的问题。现在 A B 两个线程并行，操作系统会不停的在 A B 两个线程之间切换，达到一种伪并行的效果，假设切换的频率是每秒一次，切换的成本是 0.1 秒(主要是栈切换)，总共需要 20 + 19 * 0.1 = 21.9 秒。如果使用协程的方式，可以先运行协程 A ，A 结束的时候让位给协程 B ，只发生一次切换，总时间是 20 + 1 * 0.1 = 20.1 秒。如果系统是双核的，而且线程是标准线程，那么 A B 两个线程就可以真并行，总时间只需要 10 秒，而协程的方案仍然需要 20.1 秒。在一个线程中，协程其实只能串行执行，所以无法使用多CPU来实现协程真正的并行执行，协程没有标准线程那样同时使用多CPU的能力。
参考文章：https://blog.csdn.net/mu_wind/article/details/124616643