最新Python核心编程总结(五、多任务编程之进程与线程)，被面试官问的Python问题难倒了

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

add: 3

add: 4

add_data: [0, 1, 2, 3, 4]

main: []

read_data []

原因解释：

2、进程之间不共享全局变量小结

• 创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

3、主进程等待所有子进程执行结束

假如我们现在创建一个子进程，这个子进程执行完大概需要2秒钟，现在让主进程执行0.5秒钟就退出程序，查看一下执行结果，示例代码如下:

import multiprocessing

import time

定义进程所需要执行的任务

def task():

for i in range(10):

print(“任务执行中…”)

time.sleep(0.2)

if name == ‘main’:

创建子进程

sub_process = multiprocessing.Process(target=task)

sub_process.start()

主进程延时0.5秒钟

time.sleep(0.5)

print(“over”)

exit()

总结： 主进程会等待所有的子进程执行完成以后程序再退出

执行结果：

任务执行中…

任务执行中…

任务执行中…

over

任务执行中…

任务执行中…

任务执行中…

任务执行中…

任务执行中…

任务执行中…

任务执行中…

通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束

假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?

我们可以设置守护主进程或者在主进程退出之前让子进程销毁

守护主进程：

• 守护主进程就是主进程退出子进程销毁不再执行

子进程销毁：

• 子进程执行结束

保证主进程正常退出的示例代码:

import multiprocessing

import time

定义进程所需要执行的任务

def task():

for i in range(10):

print(“任务执行中…”)

time.sleep(0.2)

if name == ‘main’:

创建子进程

sub_process = multiprocessing.Process(target=task)

设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程

sub_process.daemon = True

sub_process.start()

time.sleep(0.5)

print(“over”)

让子进程销毁

sub_process.terminate()

exit()

总结： 主进程会等待所有的子进程执行完成以后程序再退出

如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

执行结果：

任务执行中…

任务执行中…

任务执行中…

over

• 设置守护主进程方式： 子进程对象.daemon = True

• 销毁子进程方式： 子进程对象.terminate()

1.5、线程

---

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。

1.6、多线程的使用

---

1. 导入线程模块

#导入线程模块

import threading

2. 线程类Thread参数说明

Thread([group [, target [, name [, args [, kwargs]]]]])

• group: 线程组，目前只能使用None

• target: 执行的目标任务名

• args: 以元组的方式给执行任务传参

• kwargs: 以字典方式给执行任务传参

• name: 线程名，一般不用设置

启动线程：

• 启动线程使用 start 方法

1.6.1、多线程完成多任务的代码

import threading

import time

唱歌任务

def sing():

扩展： 获取当前线程

print(“sing当前执行的线程为：”, threading.current_thread())

for i in range(3):

print(“正在唱歌…%d” % i)

time.sleep(1)

跳舞任务

def dance():

扩展： 获取当前线程

print(“dance当前执行的线程为：”, threading.current_thread())

for i in range(3):

print(“正在跳舞…%d” % i)

time.sleep(1)

if name == ‘main’:

扩展： 获取当前线程

print(“当前执行的线程为：”, threading.current_thread())

创建唱歌的线程

target： 线程执行的函数名

sing_thread = threading.Thread(target=sing)

创建跳舞的线程

dance_thread = threading.Thread(target=dance)

开启线程

sing_thread.start()

dance_thread.start()

执行结果：

正在唱歌…0

正在跳舞…0

正在唱歌…1

正在跳舞…1

正在跳舞…2

正在唱歌…2

总结：

1. 导入线程模块

• import threading

2. 创建子线程并指定执行的任务

• sub_thread = threading.Thread(target=任务名)

3. 启动线程执行任务

• sub_thread.start()

1.6.2、线程执行带有参数的任务

前面我们使用线程执行的任务是没有参数的，假如我们使用线程执行的任务带有参数，如何给函数传参呢?

Thread类执行任务并给任务传参数有两种方式:

• args 表示以元组的方式给执行任务传参

• kwargs 表示以字典方式给执行任务传参

1、args参数的使用

import threading

import time

带有参数的任务

def task(count):

for i in range(count):

print(“任务执行中…”)

time.sleep(0.2)

else:

print(“任务执行完成”)

if name == ‘main’:

创建子线程

args: 以元组的方式给任务传入参数

sub_thread = threading.Thread(target=task, args=(5,))

sub_thread.start()

执行结果：

任务执行中…

任务执行中…

任务执行中…

任务执行中…

任务执行中…

任务执行完成

2、kwargs参数的使用

import threading

import time

带有参数的任务

def task(count):

for i in range(count):

print(“任务执行中…”)

time.sleep(0.2)

else:

print(“任务执行完成”)

if name == ‘main’:

创建子线程

kwargs: 表示以字典方式传入参数

sub_thread = threading.Thread(target=task, kwargs={“count”: 3})

sub_thread.start()

执行结果：

任务执行中…

任务执行中…

任务执行中…

任务执行完成

3、小结

线程执行任务并传参有两种方式：

• 元组方式传参(args) ：元组方式传参一定要和参数的顺序保持一致。

• 字典方式传参(kwargs)：字典方式传参字典中的key一定要和参数名保持一致。

1.6.3、线程的注意点

1. 线程之间执行是无序的

2. 主线程会等待所有的子线程执行结束再结束

3. 线程之间共享全局变量

4. 线程之间共享全局变量数据出现错误问题

1、线程之间执行是无序的

import threading

import time

def task():

time.sleep(1)

print(“当前线程:”, threading.current_thread().name)

if name == ‘main’:

for _ in range(5):

sub_thread = threading.Thread(target=task)

sub_thread.start()

执行结果：

当前线程: Thread-1

当前线程: Thread-2

当前线程: Thread-4

当前线程: Thread-5

当前线程: Thread-3

说明：

• 线程之间执行是无序的，它是由cpu调度决定的 ，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。

• 进程之间执行也是无序的，它是由操作系统调度决定的，操作系统调度哪个进程，哪个进程就先执行，没有调度的进程不能执行。

2、主线程会等待所有子线程执行结束再结束

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果，示例代码如下:

import threading

import time

测试主线程是否会等待子线程执行完成以后程序再退出

def show_info():

for i in range(5):

print(“test:”, i)

time.sleep(0.5)

if name == ‘main’:

sub_thread = threading.Thread(target=show_info)

sub_thread.start()

主线程延时1秒

time.sleep(1)

print(“over”)

执行结果：

test: 0

test: 1

over

test: 2

test: 3

test: 4

通过上面代码的执行结果，我们可以得知: 主线程会等待所有的子线程执行结束再结束

假如我们就让主线程执行1秒钟，子线程就销毁不再执行，那怎么办呢?

我们可以设置守护主线程 ：守护主线程就是主线程退出子线程销毁不再执行。

设置守护主线程有两种方式：

1. threading.Thread(target=show_info, daemon=True)

2. 线程对象.setDaemon(True)

设置守护主线程示例：

import threading

import time

测试主线程是否会等待子线程执行完成以后程序再退出

def show_info():

for i in range(5):

print(“test:”, i)

time.sleep(0.5)

if name == ‘main’:

创建子线程守护主线程

daemon=True 守护主线程

守护主线程方式1

sub_thread = threading.Thread(target=show_info, daemon=True)

设置成为守护主线程，主线程退出后子线程直接销毁不再执行子线程的代码

守护主线程方式2

sub_thread.setDaemon(True)

sub_thread.start()

主线程延时1秒

time.sleep(1)

print(“over”)

执行结果：

test: 0

test: 1

over

3、线程之间共享全局变量

需求：

1. 定义一个列表类型的全局变量

2. 创建两个子线程分别执行向全局变量添加数据的任务和向全局变量读取数据的任务

3. 查看线程之间是否共享全局变量数据

import threading

import time

定义全局变量

my_list = list()

写入数据任务

def write_data():

for i in range(5):

my_list.append(i)

time.sleep(0.1)

print(“write_data:”, my_list)

读取数据任务

def read_data():

print(“read_data:”, my_list)

if name == ‘main’:

创建写入数据的线程

write_thread = threading.Thread(target=write_data)

创建读取数据的线程

read_thread = threading.Thread(target=read_data)

write_thread.start()

延时

time.sleep(1)

主线程等待写入线程执行完成以后代码在继续往下执行

write_thread.join()

print(“开始读取数据啦”)

read_thread.start()

执行结果：

write_data: [0, 1, 2, 3, 4]

开始读取数据啦

read_data: [0, 1, 2, 3, 4]

4、线程之间共享全局变量数据出现错误问题

需求：

1. 定义两个函数，实现循环100万次，每循环一次给全局变量加1

2. 创建两个子线程执行对应的两个函数，查看计算后的结果

import threading

定义全局变量

g_num = 0

循环一次给全局变量加1

def sum_num1():

for i in range(1000000):

global g_num

g_num += 1

print(“sum1:”, g_num)

循环一次给全局变量加1

def sum_num2():

for i in range(1000000):

global g_num

g_num += 1

print(“sum2:”, g_num)

if name == ‘main’:

创建两个线程

first_thread = threading.Thread(target=sum_num1)

second_thread = threading.Thread(target=sum_num2)

启动线程

first_thread.start()

启动线程

second_thread.start()

执行结果：

sum1: 1210949

sum2: 1496035

注意点：多线程同时对全局变量操作数据发生了错误

错误分析：

两个线程first_thread和second_thread都要对全局变量g_num(默认是0)进行加1运算，但是由于是多线程同时操作，有可能出现下面情况：

1. 在g_num=0时，first_thread取得g_num=0。此时系统把first_thread调度为”sleeping”状态，把second_thread转换为”running”状态，t2也获得g_num=0

2. 然后second_thread对得到的值进行加1并赋给g_num，使得g_num=1

3. 然后系统又把second_thread调度为”sleeping”，把first_thread转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。

4. 这样导致虽然first_thread和first_thread都对g_num加1，但结果仍然是g_num=1

全局变量数据错误的解决办法:

线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说, 好比现实生活中的对讲机

线程同步的方式:

1. 线程等待(join)

2. 互斥锁

线程等待示例代码：

import threading

定义全局变量

g_num = 0

循环1000000次每次给全局变量加1

def sum_num1():

for i in range(1000000):

global g_num

g_num += 1

print(“sum1:”, g_num)

循环1000000次每次给全局变量加1

def sum_num2():

for i in range(1000000):

global g_num

g_num += 1

print(“sum2:”, g_num)

if name == ‘main’:

创建两个线程

first_thread = threading.Thread(target=sum_num1)

second_thread = threading.Thread(target=sum_num2)

启动线程

first_thread.start()

主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程

线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行

first_thread.join()

启动线程

second_thread.start()

执行结果：

sum1: 1000000

sum2: 2000000

5、小结

1. 线程执行执行是无序的

2. 主线程默认会等待所有子线程执行结束再结束，设置守护主线程的目的是主线程退出子线程销毁。

3. 线程之间共享全局变量，好处是可以对全局变量的数据进行共享。

4. 线程之间共享全局变量可能会导致数据出现错误问题，可以使用线程同步方式来解决这个问题。

• 线程等待(join)

1.7、互斥锁

---

互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。

注意：

• 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

1.7.1、互斥锁的使用

互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。

互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

threading模块中定义了Lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。

互斥锁使用步骤：

创建锁

mutex = threading.Lock()

上锁

mutex.acquire()

‘’’

这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定

‘’’

释放锁

mutex.release()

注意点：

• acquire和release方法之间的代码同一时刻只能有一个线程去操作

• 如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。

1.7.2、操作

使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading

定义全局变量

g_num = 0

创建全局互斥锁

lock = threading.Lock()

循环一次给全局变量加1

def sum_num1():

上锁

lock.acquire()

for i in range(1000000):

global g_num

g_num += 1

print(“sum1:”, g_num)

释放锁

lock.release()

循环一次给全局变量加1

def sum_num2():

上锁

lock.acquire()

for i in range(1000000):

global g_num

g_num += 1

print(“sum2:”, g_num)

释放锁

lock.release()

if name == ‘main’:

创建两个线程

first_thread = threading.Thread(target=sum_num1)

second_thread = threading.Thread(target=sum_num2)

启动线程

first_thread.start()

second_thread.start()

提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待

加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

执行结果：

sum1: 1000000

sum2: 2000000

说明：

通过执行结果可以地址互斥锁能够保证多个线程访问共享数据不会出现数据错误问题

1.7.3、小结

• 互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题

• 使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行

• 使用互斥锁会影响代码的执行效率，多任务改成了单任务执行

• 互斥锁如果没有使用好容易出现死锁的情况

1.8、死锁

---

死锁: 一直等待对方释放锁的情景就是死锁

示例：

import threading

import time

创建互斥锁

lock = threading.Lock()

根据下标去取值， 保证同一时刻只能有一个线程去取值

def get_value(index):

上锁

lock.acquire()

print(threading.current_thread())

my_list = [3,6,8,1]

判断下标释放越界

if index >= len(my_list):

print(“下标越界:”, index)

return

value = my_list[index]

print(value)

time.sleep(0.2)

释放锁

lock.release()

if name == ‘main’:

模拟大量线程去执行取值操作

for i in range(30):

sub_thread = threading.Thread(target=get_value, args=(i,))

sub_thread.start()

1.8.1、避免死锁

在合适的地方释放锁

import threading

import time

创建互斥锁

lock = threading.Lock()

根据下标去取值， 保证同一时刻只能有一个线程去取值

def get_value(index):

上锁

lock.acquire()

print(threading.current_thread())

my_list = [3,6,8,1]

if index >= len(my_list):

print(“下标越界:”, index)

当下标越界需要释放锁，让后面的线程还可以取值

lock.release()

return

value = my_list[index]

做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。

别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。

我先来介绍一下这些东西怎么用，文末抱走。

---

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

（4）200多本电子书

这些年我也收藏了很多电子书，大概200多本，有时候带实体书不方便的话，我就会去打开电子书看看，书籍可不一定比视频教程差，尤其是权威的技术书籍。

基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。

（5）Python知识点汇总

知识点汇总有点像学习路线，但与学习路线不同的点就在于，知识点汇总更为细致，里面包含了对具体知识点的简单说明，而我们的学习路线则更为抽象和简单，只是为了方便大家只是某个领域你应该学习哪些技术栈。

（6）其他资料

还有其他的一些东西，比如说我自己出的Python入门图文类教程，没有电脑的时候用手机也可以学习知识，学会了理论之后再去敲代码实践验证，还有Python中文版的库资料、MySQL和HTML标签大全等等，这些都是可以送给粉丝们的东西。

这些都不是什么非常值钱的东西，但对于没有资源或者资源不是很好的学习者来说确实很不错，你要是用得到的话都可以直接抱走，关注过我的人都知道，这些都是可以拿到的。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！