封面图片来源：沙沙野

内容概览进程必备的理论基础

进程的概念

并行和并发

进程的三状态

同步异步

进程模块

关于进程必备的理论基础操作系统的作用隐藏丑陋复杂的硬件接口，提供良好的抽象接口

管理、调度进程，并且将多个进程对硬件的竞争变得有序

2. 多道技术产生背景针对单核，实现并发

现在的主机一般是多核，那么每个核都会利用多道技术

有 4 个 cpu，运行于 cpu1 的某个程序遇到 io 阻塞，会等到 io 结束再重新调度

会被调度到 4 个 cpu 中的任意一个，具体由操作系统调度算法决定

3. 多道技术空间上的复用：如内存中同时有多道程序

4. 多道技术时间上的复用复用一个 cpu 的时间片

注意，遇到 io 切，占用 cpu 时间过长也切

核心在于切之前将进程的状态保存下来

这样才能保证下次切换回来时，能基于上次切走的位置继续运行

进程的概念进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动

进程是操作系统动态执行的基本单元

在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元

进程与程序的区别程序是指令和数据的有序集合，是一个静态的概念。程序可以作为一种软件资料长期存在，是永久的

进程是程序在处理机上的一次执行过程,它是一个动态的概念。进程是有一定生命期的，是暂时的

5. 注意：同一个程序执行两次，就会在操作系统中出现两个进程。所以可以同时运行一个软件，分别做不同的事情也不会混乱，比如可以打开两个Pycharm做不同的事

6. 进程调度要想多个进程交替运行，操作系统必须对这些进程进行调度

这个调度也不是随即进行的，而是需要遵循一定的法则

由此就有了进程的调度算法：先来先服务调度算法、短作业优先调度算法、时间片轮转法、多级反馈队列

并行和并发并行是指在一个时间点上，有多个进程在被 cpu 计算，比如赛跑，两个人都在不停的往前跑

并发是指资源有限的情况下，在一个时间段上，有多个进程在被 cpu 计算，交替轮流使用资源

并行与并发的区别并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器

并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个 session

进程的三状态在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态就绪

运行

阻塞

2. 举例说明什么是 argv，什么是阻塞

import sys

print(sys.argv)

# 运行结果：

['G:/course_select/进程的概念.py']

# argv 指参数

# sys.argv 是 Python 解释器在运行的时候传递进来的参数

# 首先在cmd输入以下信息：

python G:/course_select/进程的概念.py

# 打印结果：

['G:/course_select/进程的概念.py']

# 然后在cmd中切换路径到G盘，接着输入 python course_select/进程的概念.py

# 打印结果：

['course_select/进程的概念.py']

# 接着，再在cmd中输入：python course_select/进程的概念.py 123 abc

# 打印结果：

['course_select/进程的概念.py', '123', 'abc']

# 因此，以下程序不能在编辑器里运行，只能在 cmd 里面使用 Python 运行本文件

# 然后要在后面加上 aaa bbb

# 就像上面的 python course_select/进程的概念.py 123 abc 一样

if sys.argv[1] == "aaa" and sys.argv[2] == "bbb":

print("登录成功")

else:

print("登录失败")

exit()

print(666)

# 而如果使用input(),其实就是一种阻塞

3. 进程的三状态图

同步异步同步：形象的说，一件事的执行必须依赖另一件事的结束，强调的是顺序性

异步： 形象的说，两件事情可以同时进行

注意：同步异步和并行、并发没关系

阻塞：等待，比如 input sleep recv accept recvfrom

非阻塞：不等待，start/terminate 都是非阻塞的

阻塞与非阻塞主要是从程序(线程)等待消息通知时的状态角度来说的

可以分为四类：同步阻塞

异步阻塞

同步非阻塞

异步非阻塞

start/terminate 都是非阻塞的

进程模块跟进程相关的基本都在这个模块里：multiprocessing

父进程与子进程的对比分析父进程，比如运行本文件

子进程，运行 Process(target=func).start()

父进程与子进程数据隔离

主进程等待子进程结束之后再结束

子进程和主进程之间默认是异步的

from multiprocessing import Process

import time

def func():

time.sleep(1)

print(666)

if __name__ == "__main__":

# 开启了一个新的进程，在这个新的进程里执行的 func()

Process(target=func).start()

time.sleep(1)

# 主进程

print(777)

# 777

# 666

# 运行结果仔细观察发现有异步的效果

# 也就是说，主进程和新的进程同时执行

3. 上面的示例中为什么要有 if __name__ == "__main__"？其实这是 windows 操作系统开启子进程的方式问题

4. 继续深入

import time

import os

from multiprocessing import Process

def func():

time.sleep(1)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

# 代码执行到这里并不代表开启了子进程

p = Process(target=func)

# 开启了一个子进程，并执行func()

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 主进程运行的结果

777 12340 1636

# 子进程运行的结果

666 7604 12340

# 由上面两行结果可以得出：

# 利用 os.getpid() 证明两个进程不一样

# 另外每次运行，os.getpid() 结果都不一样

# 但是，12340 是主进程的 id，7604 是子进程的 id

# 1636 是 Pycharm 的 id，排列特点不变

5. 开启多个相同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(3)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

for i in range(10):

p = Process(target=func)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 这里需要注意一点：Python 程序一直都是逐行执行

# 但是因为这里设置了时间延迟，因此会先执行主程序的代码

# 运行结果：

777 29006 3833 # 暂停 2s 后再有下面的结果

666 29007 29006

666 29009 29006

666 29008 29006

666 29010 29006

666 29013 29006

666 29011 29006

666 29012 29006

666 29014 29006

666 29016 29006

666 29015 29006

# 观察结果发现主进程只运行了一次

# 然后剩下的全是一个子进程重新运行的结果

# 主进程运行完不会结束，它会等子进程全部运行结束

# 注意变量 p 拿到的是最后一个子进程的 id

6. 开启多个不同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(2)

print(666, os.getpid(), os.getppid())

def func2():

print(111)

if __name__ == "__main__":

for i in range(3):

p = Process(target=func)

p.start()

for i in range(2):

p = Process(target=func2)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 运行程序时仔细观察结果显示顺序：

111

111

777 29316 3833

666 29319 29316

666 29317 29316

666 29318 29316

7. 给子进程传参示例

from multiprocessing import Process

def func(name):

print(666, name)

if __name__ == "__main__":

p = Process(target=func,args=(777,)) # 注意是一个元组

p.start()

import time

from multiprocessing import Process

def func(num, name):

time.sleep(1)

print(num, "hello", name)

if __name__ == "__main__":

for i in range(10):

p = Process(target=func, args=(i, "abc"))

p.start()

print("主进程")

# 运行结果：

666 777

主进程

0 hello abc

2 hello abc

1 hello abc

3 hello abc

5 hello abc

4 hello abc

6 hello abc

7 hello abc

8 hello abc

9 hello abc

# 多运行几次，发现子进程并不是完全按顺序运行的

# 比如上面先出结果 2 hello abc，再出结果 1 hello abc

8. 子进程可以有返回值吗：不能有返回值，因为子进程函数中的返回值无法传递给父进程

import time

from multiprocessing import Process

def func():

time.sleep(3)

print("这是子进程,3s后才运行")

if __name__ == "__main__":

Process(target=func).start()

print("主进程")

# 运行结果：

主进程

这是子进程,3s后才运行

# 主进程会默认等待子进程结束之后才结束

# 因为父进程要负责回收子进程占用的操作系统资源