帮你搞懂Python进程,线程与协程

zoukankan html css js c++ java

帮你搞懂Python进程,线程与协程
本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425.html
在操作系统中，每一个独立运行的程序，都占有操作系统分配的资源，这些程序中间互不干涉，都只负责运行自己的程序代码，这就是进程。

但是当操作系统频繁的创建销毁进程时，大量的系统资源被浪费在创建和销毁的过程中。而随着多核心 cpu 的出现，线程也逐渐代替了进程，成为了操作系统可以独立运行的基本单位。

当进程不是多线程程序时，存在于进程当中的唯一线程，便是进程本身运行的代码块。

而当多线程出现在一个进程中时，则多个线程之间共享此进程的资源，并接受操作系统的调度来运行每个线程。

状态

协程

为了了解协程的概念，我们先来了解一下并发和并行。

并行

并行比较好理解，即有多个程序在同时执行，这里的程序指的是操作系统的线程。

每个 cpu 核心，只能在同一个时刻运行一组指令，意味着同一时刻，一个核心上只有一个线程在执行。

当 cpu 有四个核心时，他只可以执行4个线程。

并发

想要了解并发，就需要知道和。

同步阻塞

当程序中的一个 I/O 操作，会占据比较长的时间，这时候，程序没有被挂起，且一直在等待网络数据传输，无法进行其他操作，这时候就是同步阻塞。

同步的一个概念就是，网络传输完成后也无法告知主程序操作完成，这就导致了主程序：
- 要么只能进行等待 I/O 完成
- 要么轮询去查看是否传输是否已经完成
当然，轮询时候可以进行其他的操作，这时候，就是非阻塞的状态，即同步非阻塞。

同步非阻塞

非阻塞的概念即主程序可以进行其他的操作。

异步阻塞

有同步，就有异步。

而异步阻塞与同步阻塞相同，主程序啥也不干，就等着 I/O 操作完成。

异步非阻塞

异步非阻塞状态，便是并发的关键。

当主程序使用异步 I/O 操作时，并不会影响主程序后续的运行，而当异步 I/O 操作完成后，会主动通知主程序进行其他操作，这样就减少了轮询过程中的资源消耗，专注于其他工作。

并发

而并发就是异步非阻塞状态下的一种形式，当程序执行操作 a 时，使 a 的 I/O 异步操作，这时程序去执行操作 b, 在外部看来，a 和 b 时同时被执行的，然而他们只运行在在一个线程当中。

与线程、进程不同的是，协程并不是操作系统物理层面存在的一种程序。

协程是程序级别的，由程序编写者自己操控整个协程的生命周期。这样就实现了类似操作系统操作多线程一样的效果，但是省下了现成的切换中造成的资源消耗。

而通过程序来操纵协程，就造成了cpu 一直在运行，并且是多个协程一直在运行的假象，也就变成了并发。

实例

下面我们通过几个实例来说明，在 python 中的进程、线程和协程的关系。

进程实例

在 python 中我们如何编写多进程的程序呢？

答案是使用模块 multiprocessing 进行实现。
```
import time  
from multiprocessing import Process  
  
class Test(Process):  
    def __init__(self):  
        super().__init__()  
      
    def run(self):  
        while True:  
            print("process b is run")  
            time.sleep(1)
```
通过继承 multiprocessing 的 Process ，实现进程类，然后实现 run 方法，即可在此方法中实现进程要运行的内容。
```
from process_b import Test  
import time  
  
if __name__ == "__main__":  
    t = Test()  
    t.start()  
    while True:  
        print("process a run")  
        time.sleep(1)
```
调用方法也非常简单，直接使用 Test 实例化对象，然后调用对象的成员函数 start() 即可。
```
python3 process_a.py  
process a run  
process b is run  
process b is run  
process a run  
process a run  
process b is run  
process b is run  
process a run
```
线程实例

Cpython 中由于存在 GIL ，所以多线程在实际应用中也会变为单核 cpu 上的线程，排队运行。
```
import threading  
import time  
  
class ThreadTest (threading.Thread):  
    def __init__(self, name):  
        super().__init__()  
        self.name = name  
  
    def run(self):  
        while True:  
            print(f"i am in thread {self.name}")  
            time.sleep(1)  
  
  
if __name__ == "__main__":  
    threads = []  
    for i in range(4):  
        t = ThreadTest(i)  
        threads.append(t)  
      
    for t in threads:  
        t.start()  
      
    for t in threads:  
        t.join()
```
通过继承 threading.Thread 来实现线程类，然后通过实例化，生成对象，调用对象的 start() 即可启动线程。

运行结果
```
python3 thread_a.py  
i am in thread 0  
i am in thread 1  
i am in thread 2  
i am in thread 3  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1
```
协程

python3 将 asyncio 加入到了标准库。
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
运行结果
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
总结

以上就是本节的所有内容，主要简单地讲解了关于进程、线程和协程的概念和例子。本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/
在操作系统中，每一个独立运行的程序，都占有操作系统分配的资源，这些程序中间互不干涉，都只负责运行自己的程序代码，这就是进程。

但是当操作系统频繁的创建销毁进程时，大量的系统资源被浪费在创建和销毁的过程中。而随着多核心 cpu 的出现，线程也逐渐代替了进程，成为了操作系统可以独立运行的基本单位。

当进程不是多线程程序时，存在于进程当中的唯一线程，便是进程本身运行的代码块。

而当多线程出现在一个进程中时，则多个线程之间共享此进程的资源，并接受操作系统的调度来运行每个线程。

状态

协程

为了了解协程的概念，我们先来了解一下并发和并行。

并行

并行比较好理解，即有多个程序在同时执行，这里的程序指的是操作系统的线程。

每个 cpu 核心，只能在同一个时刻运行一组指令，意味着同一时刻，一个核心上只有一个线程在执行。

当 cpu 有四个核心时，他只可以执行4个线程。

并发

想要了解并发，就需要知道和。

同步阻塞

当程序中的一个 I/O 操作，会占据比较长的时间，这时候，程序没有被挂起，且一直在等待网络数据传输，无法进行其他操作，这时候就是同步阻塞。

同步的一个概念就是，网络传输完成后也无法告知主程序操作完成，这就导致了主程序：
- 要么只能进行等待 I/O 完成
- 要么轮询去查看是否传输是否已经完成
当然，轮询时候可以进行其他的操作，这时候，就是非阻塞的状态，即同步非阻塞。

同步非阻塞

非阻塞的概念即主程序可以进行其他的操作。

异步阻塞

有同步，就有异步。

而异步阻塞与同步阻塞相同，主程序啥也不干，就等着 I/O 操作完成。

异步非阻塞

异步非阻塞状态，便是并发的关键。

当主程序使用异步 I/O 操作时，并不会影响主程序后续的运行，而当异步 I/O 操作完成后，会主动通知主程序进行其他操作，这样就减少了轮询过程中的资源消耗，专注于其他工作。

并发

而并发就是异步非阻塞状态下的一种形式，当程序执行操作 a 时，使 a 的 I/O 异步操作，这时程序去执行操作 b, 在外部看来，a 和 b 时同时被执行的，然而他们只运行在在一个线程当中。

与线程、进程不同的是，协程并不是操作系统物理层面存在的一种程序。

协程是程序级别的，由程序编写者自己操控整个协程的生命周期。这样就实现了类似操作系统操作多线程一样的效果，但是省下了现成的切换中造成的资源消耗。

而通过程序来操纵协程，就造成了cpu 一直在运行，并且是多个协程一直在运行的假象，也就变成了并发。

实例

下面我们通过几个实例来说明，在 python 中的进程、线程和协程的关系。

进程实例

在 python 中我们如何编写多进程的程序呢？

答案是使用模块 multiprocessing 进行实现。
```
import time  
from multiprocessing import Process  
  
class Test(Process):  
    def __init__(self):  
        super().__init__()  
      
    def run(self):  
        while True:  
            print("process b is run")  
            time.sleep(1)
```
通过继承 multiprocessing 的 Process ，实现进程类，然后实现 run 方法，即可在此方法中实现进程要运行的内容。
```
from process_b import Test  
import time  
  
if __name__ == "__main__":  
    t = Test()  
    t.start()  
    while True:  
        print("process a run")  
        time.sleep(1)
```
调用方法也非常简单，直接使用 Test 实例化对象，然后调用对象的成员函数 start() 即可。
```
python3 process_a.py  
process a run  
process b is run  
process b is run  
process a run  
process a run  
process b is run  
process b is run  
process a run
```
线程实例

Cpython 中由于存在 GIL ，所以多线程在实际应用中也会变为单核 cpu 上的线程，排队运行。
```
import threading  
import time  
  
class ThreadTest (threading.Thread):  
    def __init__(self, name):  
        super().__init__()  
        self.name = name  
  
    def run(self):  
        while True:  
            print(f"i am in thread {self.name}")  
            time.sleep(1)  
  
  
if __name__ == "__main__":  
    threads = []  
    for i in range(4):  
        t = ThreadTest(i)  
        threads.append(t)  
      
    for t in threads:  
        t.start()  
      
    for t in threads:  
        t.join()
```
通过继承 threading.Thread 来实现线程类，然后通过实例化，生成对象，调用对象的 start() 即可启动线程。

运行结果
```
python3 thread_a.py  
i am in thread 0  
i am in thread 1  
i am in thread 2  
i am in thread 3  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1
```
协程

python3 将 asyncio 加入到了标准库。
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
运行结果
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
总结

以上就是本节的所有内容，主要简单地讲解了关于进程、线程和协程的概念和例子。本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/
在操作系统中，每一个独立运行的程序，都占有操作系统分配的资源，这些程序中间互不干涉，都只负责运行自己的程序代码，这就是进程。

但是当操作系统频繁的创建销毁进程时，大量的系统资源被浪费在创建和销毁的过程中。而随着多核心 cpu 的出现，线程也逐渐代替了进程，成为了操作系统可以独立运行的基本单位。

当进程不是多线程程序时，存在于进程当中的唯一线程，便是进程本身运行的代码块。

而当多线程出现在一个进程中时，则多个线程之间共享此进程的资源，并接受操作系统的调度来运行每个线程。

状态

协程

为了了解协程的概念，我们先来了解一下并发和并行。

并行

并行比较好理解，即有多个程序在同时执行，这里的程序指的是操作系统的线程。

每个 cpu 核心，只能在同一个时刻运行一组指令，意味着同一时刻，一个核心上只有一个线程在执行。

当 cpu 有四个核心时，他只可以执行4个线程。

并发

想要了解并发，就需要知道和。

同步阻塞

当程序中的一个 I/O 操作，会占据比较长的时间，这时候，程序没有被挂起，且一直在等待网络数据传输，无法进行其他操作，这时候就是同步阻塞。

同步的一个概念就是，网络传输完成后也无法告知主程序操作完成，这就导致了主程序：
- 要么只能进行等待 I/O 完成
- 要么轮询去查看是否传输是否已经完成
当然，轮询时候可以进行其他的操作，这时候，就是非阻塞的状态，即同步非阻塞。

同步非阻塞

非阻塞的概念即主程序可以进行其他的操作。

异步阻塞

有同步，就有异步。

而异步阻塞与同步阻塞相同，主程序啥也不干，就等着 I/O 操作完成。

异步非阻塞

异步非阻塞状态，便是并发的关键。

当主程序使用异步 I/O 操作时，并不会影响主程序后续的运行，而当异步 I/O 操作完成后，会主动通知主程序进行其他操作，这样就减少了轮询过程中的资源消耗，专注于其他工作。

并发

而并发就是异步非阻塞状态下的一种形式，当程序执行操作 a 时，使 a 的 I/O 异步操作，这时程序去执行操作 b, 在外部看来，a 和 b 时同时被执行的，然而他们只运行在在一个线程当中。

与线程、进程不同的是，协程并不是操作系统物理层面存在的一种程序。

协程是程序级别的，由程序编写者自己操控整个协程的生命周期。这样就实现了类似操作系统操作多线程一样的效果，但是省下了现成的切换中造成的资源消耗。

而通过程序来操纵协程，就造成了cpu 一直在运行，并且是多个协程一直在运行的假象，也就变成了并发。

实例

下面我们通过几个实例来说明，在 python 中的进程、线程和协程的关系。

进程实例

在 python 中我们如何编写多进程的程序呢？

答案是使用模块 multiprocessing 进行实现。
```
import time  
from multiprocessing import Process  
  
class Test(Process):  
    def __init__(self):  
        super().__init__()  
      
    def run(self):  
        while True:  
            print("process b is run")  
            time.sleep(1)
```
通过继承 multiprocessing 的 Process ，实现进程类，然后实现 run 方法，即可在此方法中实现进程要运行的内容。
```
from process_b import Test  
import time  
  
if __name__ == "__main__":  
    t = Test()  
    t.start()  
    while True:  
        print("process a run")  
        time.sleep(1)
```
调用方法也非常简单，直接使用 Test 实例化对象，然后调用对象的成员函数 start() 即可。
```
python3 process_a.py  
process a run  
process b is run  
process b is run  
process a run  
process a run  
process b is run  
process b is run  
process a run
```
线程实例

Cpython 中由于存在 GIL ，所以多线程在实际应用中也会变为单核 cpu 上的线程，排队运行。
```
import threading  
import time  
  
class ThreadTest (threading.Thread):  
    def __init__(self, name):  
        super().__init__()  
        self.name = name  
  
    def run(self):  
        while True:  
            print(f"i am in thread {self.name}")  
            time.sleep(1)  
  
  
if __name__ == "__main__":  
    threads = []  
    for i in range(4):  
        t = ThreadTest(i)  
        threads.append(t)  
      
    for t in threads:  
        t.start()  
      
    for t in threads:  
        t.join()
```
通过继承 threading.Thread 来实现线程类，然后通过实例化，生成对象，调用对象的 start() 即可启动线程。

运行结果
```
python3 thread_a.py  
i am in thread 0  
i am in thread 1  
i am in thread 2  
i am in thread 3  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1
```
协程

python3 将 asyncio 加入到了标准库。
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
运行结果
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
总结

以上就是本节的所有内容，主要简单地讲解了关于进程、线程和协程的概念和例子。本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/
在操作系统中，每一个独立运行的程序，都占有操作系统分配的资源，这些程序中间互不干涉，都只负责运行自己的程序代码，这就是进程。

但是当操作系统频繁的创建销毁进程时，大量的系统资源被浪费在创建和销毁的过程中。而随着多核心 cpu 的出现，线程也逐渐代替了进程，成为了操作系统可以独立运行的基本单位。

当进程不是多线程程序时，存在于进程当中的唯一线程，便是进程本身运行的代码块。

而当多线程出现在一个进程中时，则多个线程之间共享此进程的资源，并接受操作系统的调度来运行每个线程。

状态

协程

为了了解协程的概念，我们先来了解一下并发和并行。

并行

并行比较好理解，即有多个程序在同时执行，这里的程序指的是操作系统的线程。

每个 cpu 核心，只能在同一个时刻运行一组指令，意味着同一时刻，一个核心上只有一个线程在执行。

当 cpu 有四个核心时，他只可以执行4个线程。

并发

想要了解并发，就需要知道和。

同步阻塞

当程序中的一个 I/O 操作，会占据比较长的时间，这时候，程序没有被挂起，且一直在等待网络数据传输，无法进行其他操作，这时候就是同步阻塞。

同步的一个概念就是，网络传输完成后也无法告知主程序操作完成，这就导致了主程序：
- 要么只能进行等待 I/O 完成
- 要么轮询去查看是否传输是否已经完成
当然，轮询时候可以进行其他的操作，这时候，就是非阻塞的状态，即同步非阻塞。

同步非阻塞

非阻塞的概念即主程序可以进行其他的操作。

异步阻塞

有同步，就有异步。

而异步阻塞与同步阻塞相同，主程序啥也不干，就等着 I/O 操作完成。

异步非阻塞

异步非阻塞状态，便是并发的关键。

当主程序使用异步 I/O 操作时，并不会影响主程序后续的运行，而当异步 I/O 操作完成后，会主动通知主程序进行其他操作，这样就减少了轮询过程中的资源消耗，专注于其他工作。

并发

而并发就是异步非阻塞状态下的一种形式，当程序执行操作 a 时，使 a 的 I/O 异步操作，这时程序去执行操作 b, 在外部看来，a 和 b 时同时被执行的，然而他们只运行在在一个线程当中。

与线程、进程不同的是，协程并不是操作系统物理层面存在的一种程序。

协程是程序级别的，由程序编写者自己操控整个协程的生命周期。这样就实现了类似操作系统操作多线程一样的效果，但是省下了现成的切换中造成的资源消耗。

而通过程序来操纵协程，就造成了cpu 一直在运行，并且是多个协程一直在运行的假象，也就变成了并发。

实例

下面我们通过几个实例来说明，在 python 中的进程、线程和协程的关系。

进程实例

在 python 中我们如何编写多进程的程序呢？

答案是使用模块 multiprocessing 进行实现。
```
import time  
from multiprocessing import Process  
  
class Test(Process):  
    def __init__(self):  
        super().__init__()  
      
    def run(self):  
        while True:  
            print("process b is run")  
            time.sleep(1)
```
通过继承 multiprocessing 的 Process ，实现进程类，然后实现 run 方法，即可在此方法中实现进程要运行的内容。
```
from process_b import Test  
import time  
  
if __name__ == "__main__":  
    t = Test()  
    t.start()  
    while True:  
        print("process a run")  
        time.sleep(1)
```
调用方法也非常简单，直接使用 Test 实例化对象，然后调用对象的成员函数 start() 即可。
```
python3 process_a.py  
process a run  
process b is run  
process b is run  
process a run  
process a run  
process b is run  
process b is run  
process a run
```
线程实例

Cpython 中由于存在 GIL ，所以多线程在实际应用中也会变为单核 cpu 上的线程，排队运行。
```
import threading  
import time  
  
class ThreadTest (threading.Thread):  
    def __init__(self, name):  
        super().__init__()  
        self.name = name  
  
    def run(self):  
        while True:  
            print(f"i am in thread {self.name}")  
            time.sleep(1)  
  
  
if __name__ == "__main__":  
    threads = []  
    for i in range(4):  
        t = ThreadTest(i)  
        threads.append(t)  
      
    for t in threads:  
        t.start()  
      
    for t in threads:  
        t.join()
```
通过继承 threading.Thread 来实现线程类，然后通过实例化，生成对象，调用对象的 start() 即可启动线程。

运行结果
```
python3 thread_a.py  
i am in thread 0  
i am in thread 1  
i am in thread 2  
i am in thread 3  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1
```
协程

python3 将 asyncio 加入到了标准库。
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
运行结果
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
总结

以上就是本节的所有内容，主要简单地讲解了关于进程、线程和协程的概念和例子。本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/
在操作系统中，每一个独立运行的程序，都占有操作系统分配的资源，这些程序中间互不干涉，都只负责运行自己的程序代码，这就是进程。

但是当操作系统频繁的创建销毁进程时，大量的系统资源被浪费在创建和销毁的过程中。而随着多核心 cpu 的出现，线程也逐渐代替了进程，成为了操作系统可以独立运行的基本单位。

当进程不是多线程程序时，存在于进程当中的唯一线程，便是进程本身运行的代码块。

而当多线程出现在一个进程中时，则多个线程之间共享此进程的资源，并接受操作系统的调度来运行每个线程。

状态

协程

为了了解协程的概念，我们先来了解一下并发和并行。

并行

并行比较好理解，即有多个程序在同时执行，这里的程序指的是操作系统的线程。

每个 cpu 核心，只能在同一个时刻运行一组指令，意味着同一时刻，一个核心上只有一个线程在执行。

当 cpu 有四个核心时，他只可以执行4个线程。

并发

想要了解并发，就需要知道和。

同步阻塞

当程序中的一个 I/O 操作，会占据比较长的时间，这时候，程序没有被挂起，且一直在等待网络数据传输，无法进行其他操作，这时候就是同步阻塞。

同步的一个概念就是，网络传输完成后也无法告知主程序操作完成，这就导致了主程序：
- 要么只能进行等待 I/O 完成
- 要么轮询去查看是否传输是否已经完成
当然，轮询时候可以进行其他的操作，这时候，就是非阻塞的状态，即同步非阻塞。

同步非阻塞

非阻塞的概念即主程序可以进行其他的操作。

异步阻塞

有同步，就有异步。

而异步阻塞与同步阻塞相同，主程序啥也不干，就等着 I/O 操作完成。

异步非阻塞

异步非阻塞状态，便是并发的关键。

当主程序使用异步 I/O 操作时，并不会影响主程序后续的运行，而当异步 I/O 操作完成后，会主动通知主程序进行其他操作，这样就减少了轮询过程中的资源消耗，专注于其他工作。

并发

而并发就是异步非阻塞状态下的一种形式，当程序执行操作 a 时，使 a 的 I/O 异步操作，这时程序去执行操作 b, 在外部看来，a 和 b 时同时被执行的，然而他们只运行在在一个线程当中。

与线程、进程不同的是，协程并不是操作系统物理层面存在的一种程序。

协程是程序级别的，由程序编写者自己操控整个协程的生命周期。这样就实现了类似操作系统操作多线程一样的效果，但是省下了现成的切换中造成的资源消耗。

而通过程序来操纵协程，就造成了cpu 一直在运行，并且是多个协程一直在运行的假象，也就变成了并发。

实例

下面我们通过几个实例来说明，在 python 中的进程、线程和协程的关系。

进程实例

在 python 中我们如何编写多进程的程序呢？

答案是使用模块 multiprocessing 进行实现。
```
import time  
from multiprocessing import Process  
  
class Test(Process):  
    def __init__(self):  
        super().__init__()  
      
    def run(self):  
        while True:  
            print("process b is run")  
            time.sleep(1)
```
通过继承 multiprocessing 的 Process ，实现进程类，然后实现 run 方法，即可在此方法中实现进程要运行的内容。
```
from process_b import Test  
import time  
  
if __name__ == "__main__":  
    t = Test()  
    t.start()  
    while True:  
        print("process a run")  
        time.sleep(1)
```
调用方法也非常简单，直接使用 Test 实例化对象，然后调用对象的成员函数 start() 即可。
```
python3 process_a.py  
process a run  
process b is run  
process b is run  
process a run  
process a run  
process b is run  
process b is run  
process a run
```
线程实例

Cpython 中由于存在 GIL ，所以多线程在实际应用中也会变为单核 cpu 上的线程，排队运行。
```
import threading  
import time  
  
class ThreadTest (threading.Thread):  
    def __init__(self, name):  
        super().__init__()  
        self.name = name  
  
    def run(self):  
        while True:  
            print(f"i am in thread {self.name}")  
            time.sleep(1)  
  
  
if __name__ == "__main__":  
    threads = []  
    for i in range(4):  
        t = ThreadTest(i)  
        threads.append(t)  
      
    for t in threads:  
        t.start()  
      
    for t in threads:  
        t.join()
```
通过继承 threading.Thread 来实现线程类，然后通过实例化，生成对象，调用对象的 start() 即可启动线程。

运行结果
```
python3 thread_a.py  
i am in thread 0  
i am in thread 1  
i am in thread 2  
i am in thread 3  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1  
i am in thread 3  
i am in thread 0  
i am in thread 2  
i am in thread 1
```
协程

python3 将 asyncio 加入到了标准库。
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
运行结果
```
import asyncio  
import time  
  
  
async def test(num):  
    await asyncio.sleep(num)  
    print(num)  
  
  
async def run():  
    tasks = [asyncio.create_task(test(num)) for num in range(4)]  
    [await t for t in tasks]  
  
  
def run_main():  
    asyncio.run(run())  
  
  
if __name__ == "__main__":  
    run_main()
```
总结

以上就是本节的所有内容，主要简单地讲解了关于进程、线程和协程的概念和例子。
查看全文

相关阅读:
效果1时间展示隐藏
 css书写轮播图样式
 jquery案例1导航栏事件
 jquery案例三导航展示
 go并发
 效果2滑动滑入效果
 php解决导出大数据execl问题
 jquery案例3模仿京东轮播图
 jquery案例2手风琴案例
 latex自适应resize超长表格

原文地址：https://www.cnblogs.com/lihanlin/p/12556034.html

帮你搞懂Python进程,线程与协程

状态

协程

并行

并发

同步阻塞

同步非阻塞

异步阻塞

异步非阻塞

并发

实例

进程实例

线程实例

协程

总结

状态

协程

并行

并发

同步阻塞

同步非阻塞

异步阻塞

异步非阻塞

并发

实例

进程实例

线程实例

协程

总结

状态

协程

并行

并发

同步阻塞

同步非阻塞

异步阻塞

异步非阻塞

并发

实例

进程实例

线程实例

协程

总结

状态

协程

并行

并发

同步阻塞

同步非阻塞

异步阻塞

异步非阻塞

并发

实例

进程实例

线程实例

协程

总结

状态

协程

并行

并发

同步阻塞

同步非阻塞

异步阻塞

异步非阻塞

并发

实例

进程实例

线程实例

协程

总结