【4.0】知识点小结（线程进阶）#

【一】什么是死锁与递归锁#

死锁是指两个或多个进程，在执行过程中，因争夺资源而造成了互相等待的一种现象。
- 即两个或多个进程持有各自的锁并试图获取对方持有的锁，从而导致被阻塞，不能向前执行，最终形成僵局。
- 在这种情况下，系统资源利用率极低，系统处于一种死循环状态。
递归锁（也叫可重入锁）是一种特殊的锁，它允许一个线程多次请求同一个锁，称为“递归地”请求锁
- 在该线程释放锁之前，会对锁计数器进行累加操作，线程每成功获得一次锁时，都要进行相应的解锁操作，直到锁计数器清零才能完全释放该锁。
- 递归锁能够保证同一线程在持有锁时能够再次获取该锁，而不被自己所持有的锁所阻塞，从而避免死锁的发生。
- 但是注意要正常使用递归锁，避免过多地获取锁导致性能下降。

【1】死锁#

1
from threading import Thread, Lock
2
import time
3

4
metexA = Lock()
5
metexB = Lock()
6

7

8
# 类只要加括号多次 产生的肯定不同的对象
9
# 如果你想要实现多次加括号等到的是相同的对象 - 单例模式
10

11
class MyThread(Thread):
12
    def run(self):
13
        self.func1()
14
        self.func2()
15

16
    def func1(self):
17
        metexA.acquire()
18
        # self.name：获取当前线程名
19
        print(f'{self.name} 抢到了A锁')
20
        metexB.acquire()
21
        print(f'{self.name} 抢到了B锁')
22
        metexB.release()
23
        metexA.release()
24

25
    def func2(self):
26
        metexB.acquire()
27
        # self.name：获取当前线程名
28
        print(f'{self.name} 抢到了A锁')
29
        time.sleep(2)
30
        metexA.acquire()
31
        print(f'{self.name} 抢到了B锁')
32
        metexA.release()
33
        metexB.release()
34

35

36
def main():
37
    for i in range(10):
38
        t = MyThread()
39
        t.start()
40

41

42
if __name__ == '__main__':
43
    main()
44

45
    # Thread-1 抢到了A锁
46
    # Thread-1 抢到了B锁
47
    # Thread-1 抢到了A锁
48
    # Thread-2 抢到了A锁
49
    # 线程卡死
50
    # 开启十个线程 第一个线程走完第一圈 回到原地抢 A 结果第二个线程已经拿到了A 导致AB卡死

【2】递归锁#

可以被连续的 acquire 和 release
但是只能被第一个抢到这把锁上执行上述操作
他的内部有一个计数器，每acquire一次计数 +1 每release一次计数-1
只要计数不为0，那么其他人都无法抢到该锁

1
from threading import Thread, Lock, RLock
2
import time
3

4
# 两个变量同时指向一把锁
5
metexA = metexB = RLock()
6

7

8
# 类只要加括号多次 产生的肯定不同的对象
9
# 如果你想要实现多次加括号等到的是相同的对象 - 单例模式
10

11
class MyThread(Thread):
12
    def run(self):
13
        self.func1()
14
        self.func2()
15

16
    def func1(self):
17
        metexA.acquire()
18
        # self.name：获取当前线程名
19
        print(f'{self.name} 抢到了A锁')
20
        metexB.acquire()
21
        print(f'{self.name} 抢到了B锁')
22
        metexB.release()
23
        metexA.release()
24

25
    def func2(self):
26
        metexB.acquire()
27
        # self.name：获取当前线程名
28
        print(f'{self.name} 抢到了A锁')
29
        time.sleep(2)
30
        metexA.acquire()
31
        print(f'{self.name} 抢到了B锁')
32
        metexA.release()
33
        metexB.release()
34

35

36
def main():
37
    for i in range(10):
38
        t = MyThread()
39
        t.start()
40

41

42
if __name__ == '__main__':
43
    main()
44

45
    # Thread-1 抢到了A锁
46
    # Thread-1 抢到了B锁
47
    # Thread-1 抢到了A锁
48
    # Thread-1 抢到了B锁
49
    # Thread-2 抢到了A锁
50
    # Thread-2 抢到了B锁
51
    # Thread-2 抢到了A锁
52
    # Thread-2 抢到了B锁
53
    # Thread-4 抢到了A锁
54
    # Thread-4 抢到了B锁
55
    # Thread-4 抢到了A锁
56
    # 不会卡主正常进行

【二】信号量#

信号量在不同的阶段可能对应不同的技术点
在并发编程中信号量指的是锁

如果我们将互斥锁比喻成一个厕所
那信号量就相当于多个厕所

【1】基础版 1.0#

通过信号量限制线程抢的线程开设数
线程数是5 ，只能每次5个人一起抢，一起走

1
# -*-coding: Utf-8 -*-
2
# @File : 02 信号量 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from threading import Thread, Semaphore
7
import time
8
import random
9

10
# 参数：表示开设几个空位
11
sm = Semaphore(5)
12

13

14
def task(name):
15
    sm.acquire()
16
    print(f'{name} 正在使用')
17
    # 模拟延迟
18
    # time.sleep(random.randint(1, 5))
19
    time.sleep(3)
20
    sm.release()
21

22

23
def main():
24
    for i in range(10):
25
        t = Thread(target=task, args=(i,))
26
        t.start()
27

28

29
if __name__ == '__main__':
30
    main()
31

32
    # 0 正在使用
33
    # 1 正在使用
34
    # 2 正在使用
35
    # 3 正在使用
36
    # 4 正在使用
37
    #
38
    # 5 正在使用
39
    # 7 正在使用
40
    # 6 正在使用
41
    # 9 正在使用
42
    # 8 正在使用

1
# -*-coding: Utf-8 -*-
2
# @File : 02 信号量 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from threading import Thread, Semaphore
7
import time
8
import random
9

10
# 参数：表示开设几个空位
11
sm = Semaphore(5)
12

13

14
def task(name):
15
    sm.acquire()
16
    print(f'{name} 正在使用')
17
    # 模拟延迟
18
    time.sleep(random.randint(1, 5))
19
    # time.sleep(3)
20
    sm.release()
21

22

23
def main():
24
    for i in range(20):
25
        t = Thread(target=task, args=(f'{i}玩家',))
26
        t.start()
27

28

29
if __name__ == '__main__':
30
    main()
31

32
    # 0 正在使用
33
    # 1 正在使用
34
    # 2 正在使用
35
    # 3 正在使用
36
    # 4 正在使用
37
    #
38
    # 5 正在使用
39
    # 7 正在使用
40
    # 6 正在使用
41
    # 9 正在使用
42
    # 8 正在使用

【三】Event事件#

一些进程/线程需要等待另外一些进程/线程运行完毕后才能运行，类似于发射信号一样

1
# -*-coding: Utf-8 -*-
2
# @File : 03 Event事件 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from threading import Thread, Event
7
import time
8

9
# 造了一个红绿灯
10
event = Event()
11

12

13
# 设置灯
14
def light(name):
15
    print(f'{name} 人:>>> red light')
16
    time.sleep(2)
17
    print(f'{name} 人:>>> green light')
18

19
    # 告诉等待红灯的人可以走了
20
    event.set()
21

22

23
def car(name):
24
    print(f'{name} 车:>>> 正在等红灯')
25

26
    # 等待别人的信号 ：有人触发 .set() 这个方法 表示 .wait() 可以继续向下走
27
    event.wait()
28
    print(f'{name} 车:>>> 走了')
29

30

31
def main():
32
    t = Thread(target=light, args=('dream',))
33
    t.start()
34

35
    for i in range(20):
36
        t = Thread(target=car, args=('bud',))
37
        t.start()
38

39
if __name__ == '__main__':
40
    main()
41

42
    # dream 人:>>> red light
43
    # bud 车:>>> 正在等红灯
44
    # bud 车:>>> 正在等红灯
45
    # bud 车:>>> 正在等红灯
46
    # bud 车:>>> 正在等红灯
47
    # bud 车:>>> 正在等红灯
48
    # bud 车:>>> 正在等红灯
49
    # bud 车:>>> 正在等红灯
50
    # bud 车:>>> 正在等红灯
51
    # bud 车:>>> 正在等红灯
52
    # bud 车:>>> 正在等红灯
53
    # bud 车:>>> 正在等红灯
54
    # bud 车:>>> 正在等红灯
55
    # bud 车:>>> 正在等红灯
56
    # bud 车:>>> 正在等红灯
57
    # bud 车:>>> 正在等红灯
58
    # bud 车:>>> 正在等红灯
59
    # bud 车:>>> 正在等红灯
60
    # bud 车:>>> 正在等红灯
61
    # bud 车:>>> 正在等红灯
62
    # bud 车:>>> 正在等红灯
63
    # dream 人:>>> green light
64
    # bud 车:>>> 走了
65
    # bud 车:>>> 走了
66
    # bud 车:>>> 走了bud 车:>>> 走了
67
    # bud 车:>>> 走了bud 车:>>> 走了bud 车:>>> 走了
68
    # bud 车:>>> 走了
69
    # bud 车:>>> 走了
70
    # bud 车:>>> 走了
71
    # bud 车:>>> 走了
72
    #
73
    # bud 车:>>> 走了
74
    # bud 车:>>> 走了
75
    # bud 车:>>> 走了
76
    #
77
    #
78
    # bud 车:>>> 走了
79
    # bud 车:>>> 走了bud 车:>>> 走了
80
    #
81
    # bud 车:>>> 走了
82
    # bud 车:>>> 走了
83
    # bud 车:>>> 走了

【四】线程q#

同一个进程下的多个线程数据是共享的
为什么在同一个进程下还要使用队列？
- 因为队列 = 管道 + 锁
- 使用队列是为了保证数据的安全

【1】后进先出 q

1
# -*-coding: Utf-8 -*-
2
# @File : 04 线程q .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6

7
import queue
8

9
# 我们现在使用的队列都是只能在本地测试使用
10

11
# 队列q：先进先出
12
'''
13
# 队列的常用方法
14
q = queue.Queue(3)
15
q.put(1)
16
q.get()
17
q.get_nowait()
18
q.get(timeout=3)
19
q.full()
20
q.empty()
21
'''
22

23
# （1）后进先出q
24
q = queue.LifoQueue(3)
25
q.put(1)
26
q.put(2)
27
q.put(3)
28

29
print(q.get())
30
# 3

【2】`PriorityQueue`设置队列优先级#

数字越小优先级越高

1
import queue
2

3
# （2）优先级 q
4
# 可以给防止队列中的数据设置队列优先级
5
q = queue.PriorityQueue(3)
6
# （优先级,参数）
7
q.put((10, '111'))
8
q.put((100, '222'))
9
q.put((0, '333'))
10
q.put((-5, '444'))
11
print(q.get())
12

13
# (-5, '444')
14
# (优先级, 参数)
15
# 数字越小优先级越高

【五】进程池与线程池#

【1】TCP实现并发的效果的原理#

没开设一个客户端
- 就会有一个服务端服务
服务端

1
# -*-coding: Utf-8 -*-
2
# @File : 05 进程池与线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6

7
from socket import *
8
from threading import Thread
9

10

11
def server_create(IP, PORT):
12
    server = socket()
13

14
    server.bind((IP, PORT))
15

16
    server.listen(5)
17

18
    while True:
19
        conn, addr = server.accept()
20
        t = Thread(target=conn_communication, args=(conn,))
21

22

23
def conn_communication(conn):
24
    while True:
25
        try:
26
            data = conn.recv(1024)
27
            if len(data) == 0:
28
                break
29
            print(data.decode('utf8'))
30
            conn.send(data.upper())
31
        except Exception as e:
32
            print(e)
33
            break
34
    conn.close()
35

36

37
def main():
38
    IP = '127.0.0.1'
39
    PORT = 8086
40
    t = Thread(target=server_create, args=(IP, PORT,))
41
    t.start()
42

43

44
if __name__ == '__main__':
45
    main()

客户端

1
# -*-coding: Utf-8 -*-
2
# @File : 05 进程池与线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6

7
from socket import *
8

9

10
def client_create(IP, PORT):
11
    client = socket()
12

13
    client.connect((IP, PORT))
14

15
    while True:
16
        word = b'hello world'
17
        client.send(word)
18

19
        msg = client.recv(1024)
20
        print(msg)
21

22

23
if __name__ == '__main__':
24
    IP = '127.0.0.1'
25
    PORT = 8086
26

27
    client_create(IP, PORT)

无论是开设进程还是开设线程，都需要消耗资源
只不过开始线程消耗的资源比开始进程相对少一些

硬件的开发速度永远赶不上软件开发速度

我们的宗旨是保证计算机硬件正常工作的情况下最大程度的利用它

【2】池的概念#

【1】什么是池？#

池是用来保证计算机硬件安全的情况下最大限度的利用计算机
池降低了程序的运行效率，但是保证了计算机硬件的安全，从而保证程序的正常运行

【2】基础版 2.0#

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数五倍数的线程数：可指定线程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个线程
14
# 这五个线程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个线程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ThreadPoolExecutor(5)
20

21

22
def task(n):
23
    print(n)
24
    time.sleep(2)
25

26

27
# 向池子中提交任务
28
'''
29
任务的提交方式
30
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
31
    异步：提交任务之后不等待任务的返回结果，继续执行代码
32
        返回结果如何获取？
33

34
'''
35

36

37
def normal():
38
    pool.submit(task, 1)
39

40
    # 异步提交 - 先执行子线程再打印主线程
41
    print('this is a main task')
42

43
    # 1
44
    # this is a main task
45

46
if __name__ == '__main__':
47
    normal()

【3】升级版 3.0#

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数五倍数的线程数：可指定线程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个线程
14
# 这五个线程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个线程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ThreadPoolExecutor(5)
20

21

22
def task(n):
23
    print(n)
24
    time.sleep(2)
25

26

27
# 向池子中提交任务
28
'''
29
任务的提交方式
30
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
31
    异步：提交任务之后不等待任务的返回结果，继续执行代码
32
        返回结果如何获取？
33

34
'''
35

36

37
def normal():
38
    pool.submit(task, 1)
39

40
    # 异步提交 - 先执行子线程再打印主线程
41
    print('this is a main task')
42

43
    # 1
44
    # this is a main task
45

46

47
def many_steps():
48
    for i in range(20):
49
        pool.submit(task, i)
50
    print('this is a main task')
51
    # 0
52
    # 1
53
    # 2
54
    # 3
55
    # 4
56
    # this is a main task
57
    # 先执行五个子线程，再回到主线程
58

59

60
if __name__ == '__main__':
61
    many_steps()

【4】进阶版 4.0#

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数五倍数的线程数：可指定线程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个线程
14
# 这五个线程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个线程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ThreadPoolExecutor(5)
20

21

22
def task(n):
23
    print(n)
24
    time.sleep(2)
25

26

27
# 向池子中提交任务
28
'''
29
任务的提交方式
30
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
31
    异步：提交任务之后不等待任务的返回结果，继续执行代码
32
        返回结果如何获取？
33

34
'''
35

36

37
def normal():
38
    pool.submit(task, 1)
39

40
    # 异步提交 - 先执行子线程再打印主线程
41
    print('this is a main task')
42

43
    # 1
44
    # this is a main task
45

46

47
def many_steps():
48
    for i in range(20):
49
        res = pool.submit(task, i)
50
        print(f'这是 pool的返回值:>>>>{res}')
51
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
52
        print(f'这是 pool的返回值:>>>>{res.result()}') # None
53
        # 程序由并发变成了串行
54
        # 返回的结果是 None ---> 任务的返回结果 ----> 拿到了异步提交的返回结果
55
        # res.result() ： 拿到的就是异步提交的任务的返回结果
56
    print('this is a main task')
57
    # 0这是 pool的返回值:>>>><Future at 0x1767f648a60 state=running>
58
    #
59
    # 1这是 pool的返回值:>>>><Future at 0x1767f7bce50 state=running>
60
    #
61
    # 2
62
    # 这是 pool的返回值:>>>><Future at 0x1767f7da220 state=running>
63
    # 3
64
    # 这是 pool的返回值:>>>><Future at 0x1767f7da5b0 state=running>
65
    # 4
66
    # 这是 pool的返回值:>>>><Future at 0x1767f7da940 state=running>
67
    # 这是 pool的返回值:>>>><Future at 0x1767f7dad30 state=pending>
68
    # 这是 pool的返回值:>>>><Future at 0x1767f7dae50 state=pending>
69
    # 这是 pool的返回值:>>>><Future at 0x1767f7daf70 state=pending>
70
    # 这是 pool的返回值:>>>><Future at 0x1767f9e10d0 state=pending>
71
    # 这是 pool的返回值:>>>><Future at 0x1767f9e11f0 state=pending>
72
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1310 state=pending>
73
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1430 state=pending>
74
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1550 state=pending>
75
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1670 state=pending>
76
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1790 state=pending>
77
    # 这是 pool的返回值:>>>><Future at 0x1767f9e18b0 state=pending>
78
    # 这是 pool的返回值:>>>><Future at 0x1767f9e19d0 state=pending>
79
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1af0 state=pending>
80
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1c10 state=pending>
81
    # 这是 pool的返回值:>>>><Future at 0x1767f9e1d30 state=pending>
82
    # this is a main task
83

84

85
if __name__ == '__main__':
86
    many_steps()

【5】迭代版 5.0#

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数五倍数的线程数：可指定线程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个线程
14
# 这五个线程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个线程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ThreadPoolExecutor(5)
20

21

22
def task(n):
23
    print(n)
24
    time.sleep(2)
25

26

27
# 向池子中提交任务
28
'''
29
任务的提交方式
30
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
31
    异步：提交任务之后不等待任务的返回结果，继续执行代码
32
        返回结果如何获取？
33

34
'''
35

36

37
def normal():
38
    pool.submit(task, 1)
39

40
    # 异步提交 - 先执行子线程再打印主线程
41
    print('this is a main task')
42

43
    # 1
44
    # this is a main task
45

46

47
def many_steps():
48
    # 创建任务池子
49
    res_list = []
50
    for i in range(20):
51
        res = pool.submit(task, i)
52
        print(f'这是 pool的返回值:>>>>{res}')
53
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
54
        res_list.append(res)
55
    for res in res_list:
56
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
57
        # 程序由变成了串行
58
        # res.result() ： 拿到的就是异步提交的任务的返回结果
59
        # 程序运行的结果是有序的
60

61
    print('this is a main task')
62
    # 0这是 pool的返回值:>>>><Future at 0x13bb6c68cd0 state=running>
63
    #
64
    # 1
65
    # 这是 pool的返回值:>>>><Future at 0x13bb6df9100 state=running>
66
    # 2
67
    # 这是 pool的返回值:>>>><Future at 0x13bb6df9490 state=running>
68
    # 3
69
    # 这是 pool的返回值:>>>><Future at 0x13bb6df9820 state=running>
70
    # 4
71
    # 这是 pool的返回值:>>>><Future at 0x13bb6df9bb0 state=running>
72
    # 这是 pool的返回值:>>>><Future at 0x13bb6df9f70 state=pending>
73
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff100 state=pending>
74
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff220 state=pending>
75
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff340 state=pending>
76
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff460 state=pending>
77
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff580 state=pending>
78
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff6a0 state=pending>
79
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff7c0 state=pending>
80
    # 这是 pool的返回值:>>>><Future at 0x13bb6dff8e0 state=pending>
81
    # 这是 pool的返回值:>>>><Future at 0x13bb6dffa00 state=pending>
82
    # 这是 pool的返回值:>>>><Future at 0x13bb6dffb20 state=pending>
83
    # 这是 pool的返回值:>>>><Future at 0x13bb6dffc40 state=pending>
84
    # 这是 pool的返回值:>>>><Future at 0x13bb6dffd60 state=pending>
85
    # 这是 pool的返回值:>>>><Future at 0x13bb6dffe80 state=pending>
86
    # 这是 pool的返回值:>>>><Future at 0x13bb6dfffa0 state=pending>
87
    # 56
88
    # 7
89
    # 8
90
    # 9
91
    # 这是 pool的返回值:>>>>None
92
    # 这是 pool的返回值:>>>>None
93
    # 这是 pool的返回值:>>>>None
94
    #
95
    # 这是 pool的返回值:>>>>None
96
    # 这是 pool的返回值:>>>>None
97
    # 101112
98
    # 13
99
    # 14
100
    #
101
    #
102
    # 这是 pool的返回值:>>>>None
103
    # 这是 pool的返回值:>>>>None
104
    # 这是 pool的返回值:>>>>None
105
    # 这是 pool的返回值:>>>>None
106
    # 这是 pool的返回值:>>>>None
107
    # 1516
108
    # 17
109
    # 18
110
    #
111
    # 19
112
    # 这是 pool的返回值:>>>>None
113
    # 这是 pool的返回值:>>>>None
114
    # 这是 pool的返回值:>>>>None
115
    # 这是 pool的返回值:>>>>None
116
    # 这是 pool的返回值:>>>>None
117
    # 这是 pool的返回值:>>>>None
118
    # 这是 pool的返回值:>>>>None
119
    # 这是 pool的返回值:>>>>None
120
    # 这是 pool的返回值:>>>>None
121
    # 这是 pool的返回值:>>>>None
122
    # this is a main task
123

124

125

126
if __name__ == '__main__':
127
    many_steps()

【6】增强版 6.0 - `pool.shutdown()`#

等待所有子线程结束后再打印程序运行结果

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数五倍数的线程数：可指定线程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个线程
14
# 这五个线程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个线程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ThreadPoolExecutor(5)
20

21

22
def task(n):
23
    print(n)
24
    time.sleep(2)
25

26
    return n*n
27

28

29
# 向池子中提交任务
30
'''
31
任务的提交方式
32
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
33
    异步：提交任务之后不等待任务的返回结果，继续执行代码
34
        返回结果如何获取？
35

36
'''
37

38

39
def normal():
40
    pool.submit(task, 1)
41

42
    # 异步提交 - 先执行子线程再打印主线程
43
    print('this is a main task')
44

45
    # 1
46
    # this is a main task
47

48

49
def many_steps():
50
    # 创建任务池子
51
    res_list = []
52
    for i in range(20):
53
        res = pool.submit(task, i)
54
        print(f'这是 pool的返回值:>>>>{res}')
55
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
56
        res_list.append(res)
57

58
    # 关闭线程池 - 等待所有的线程池中的任务运行完毕
59
    pool.shutdown()
60
    for res in res_list:
61
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
62
        # 程序由变成了串行
63
        # res.result() ： 拿到的就是异步提交的任务的返回结果
64
        # 程序运行的结果是有序的
65

66
    print('this is a main task')
67
    # 1
68
    # 这是 pool的返回值:>>>><Future at 0x29bc36d91c0 state=running>
69
    # 2这是 pool的返回值:>>>><Future at 0x29bc36d9550 state=running>
70
    #
71
    # 3
72
    # 这是 pool的返回值:>>>><Future at 0x29bc36d98e0 state=running>
73
    # 4
74
    # 这是 pool的返回值:>>>><Future at 0x29bc36d9c70 state=running>
75
    # 这是 pool的返回值:>>>><Future at 0x29bc36de070 state=pending>
76
    # 这是 pool的返回值:>>>><Future at 0x29bc36de1c0 state=pending>
77
    # 这是 pool的返回值:>>>><Future at 0x29bc36de2e0 state=pending>
78
    # 这是 pool的返回值:>>>><Future at 0x29bc36de400 state=pending>
79
    # 这是 pool的返回值:>>>><Future at 0x29bc36de520 state=pending>
80
    # 这是 pool的返回值:>>>><Future at 0x29bc36de640 state=pending>
81
    # 这是 pool的返回值:>>>><Future at 0x29bc36de760 state=pending>
82
    # 这是 pool的返回值:>>>><Future at 0x29bc36de880 state=pending>
83
    # 这是 pool的返回值:>>>><Future at 0x29bc36de9a0 state=pending>
84
    # 这是 pool的返回值:>>>><Future at 0x29bc36deac0 state=pending>
85
    # 这是 pool的返回值:>>>><Future at 0x29bc36debe0 state=pending>
86
    # 这是 pool的返回值:>>>><Future at 0x29bc36ded00 state=pending>
87
    # 这是 pool的返回值:>>>><Future at 0x29bc36dee20 state=pending>
88
    # 这是 pool的返回值:>>>><Future at 0x29bc36def40 state=pending>
89
    # 这是 pool的返回值:>>>><Future at 0x29bc36e50a0 state=pending>
90
    # 5
91
    # 67
92
    #
93
    # 8
94
    # 9
95
    # 10
96
    # 1112
97
    # 13
98
    #
99
    # 14
100
    # 15
101
    # 1617
102
    # 1819
103
    #
104
    #
105
    # 这是 pool的返回值:>>>>0
106
    # 这是 pool的返回值:>>>>1
107
    # 这是 pool的返回值:>>>>4
108
    # 这是 pool的返回值:>>>>9
109
    # 这是 pool的返回值:>>>>16
110
    # 这是 pool的返回值:>>>>25
111
    # 这是 pool的返回值:>>>>36
112
    # 这是 pool的返回值:>>>>49
113
    # 这是 pool的返回值:>>>>64
114
    # 这是 pool的返回值:>>>>81
115
    # 这是 pool的返回值:>>>>100
116
    # 这是 pool的返回值:>>>>121
117
    # 这是 pool的返回值:>>>>144
118
    # 这是 pool的返回值:>>>>169
119
    # 这是 pool的返回值:>>>>196
120
    # 这是 pool的返回值:>>>>225
121
    # 这是 pool的返回值:>>>>256
122
    # 这是 pool的返回值:>>>>289
123
    # 这是 pool的返回值:>>>>324
124
    # 这是 pool的返回值:>>>>361
125
    # this is a main task
126

127

128

129
if __name__ == '__main__':
130
    many_steps()

【3】进程池的使用#

【1】基础版 1.0#

开设进程的进程 ID 号不会发生改变

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time, os
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数 的进程 : 可指定进程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个进程
14
# 这五个进程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个进程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ProcessPoolExecutor(5)
20

21

22
def task(n):
23
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
24
    time.sleep(2)
25

26
    return n * n
27

28

29
# 向池子中提交任务
30
'''
31
任务的提交方式
32
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
33
    异步：提交任务之后不等待任务的返回结果，继续执行代码
34
        返回结果如何获取？
35

36
'''
37

38

39
def normal():
40
    pool.submit(task, 1)
41

42
    # 异步提交 - 先执行子线程再打印主线程
43
    print('this is a main task ')
44

45
    # 1
46
    # this is a main task
47

48

49
def many_steps():
50
    # 创建任务池子
51
    res_list = []
52
    for i in range(20):
53
        res = pool.submit(task, i)
54
        print(f'这是 pool的返回值:>>>>{res}')
55
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
56
        res_list.append(res)
57

58
    # 关闭线程池 - 等待所有的线程池中的任务运行完毕
59
    pool.shutdown()
60
    for res in res_list:
61
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
62
        # 程序由变成了串行
63
        # res.result() ： 拿到的就是异步提交的任务的返回结果
64
        # 程序运行的结果是有序的
65

66
    print('this is a main task')
67
    # 这是 pool的返回值:>>>><Future at 0x23ca907d460 state=running>
68
    # 这是 pool的返回值:>>>><Future at 0x23ca928b550 state=running>
69
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6af0 state=pending>
70
    # 这是 pool的返回值:>>>><Future at 0x23ca92f65e0 state=pending>
71
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6940 state=pending>
72
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6a00 state=pending>
73
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6b20 state=pending>
74
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6ca0 state=pending>
75
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6d30 state=pending>
76
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6e20 state=pending>
77
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6f70 state=pending>
78
    # 这是 pool的返回值:>>>><Future at 0x23ca92f6f40 state=pending>
79
    # 这是 pool的返回值:>>>><Future at 0x23ca9301220 state=pending>
80
    # 这是 pool的返回值:>>>><Future at 0x23ca9301340 state=pending>
81
    # 这是 pool的返回值:>>>><Future at 0x23ca9301310 state=pending>
82
    # 这是 pool的返回值:>>>><Future at 0x23ca9301550 state=pending>
83
    # 这是 pool的返回值:>>>><Future at 0x23ca9301670 state=pending>
84
    # 这是 pool的返回值:>>>><Future at 0x23ca9301760 state=pending>
85
    # 这是 pool的返回值:>>>><Future at 0x23ca93018b0 state=pending>
86
    # 这是 pool的返回值:>>>><Future at 0x23ca9301a00 state=pending>
87
    # 0 当前进程的进程号:>>>14680
88
    # 1 当前进程的进程号:>>>17936
89
    # 2 当前进程的进程号:>>>6028
90
    # 3 当前进程的进程号:>>>18332
91
    # 4 当前进程的进程号:>>>19176
92
    # 5 当前进程的进程号:>>>14680
93
    # 6 当前进程的进程号:>>>17936
94
    # 7 当前进程的进程号:>>>6028
95
    # 8 当前进程的进程号:>>>18332
96
    # 9 当前进程的进程号:>>>19176
97
    # 10 当前进程的进程号:>>>14680
98
    # 11 当前进程的进程号:>>>17936
99
    # 12 当前进程的进程号:>>>6028
100
    # 13 当前进程的进程号:>>>18332
101
    # 14 当前进程的进程号:>>>19176
102
    # 15 当前进程的进程号:>>>14680
103
    # 16 当前进程的进程号:>>>17936
104
    # 17 当前进程的进程号:>>>6028
105
    # 18 当前进程的进程号:>>>18332
106
    # 19 当前进程的进程号:>>>19176
107
    # 这是 pool的返回值:>>>>0
108
    # 这是 pool的返回值:>>>>1
109
    # 这是 pool的返回值:>>>>4
110
    # 这是 pool的返回值:>>>>9
111
    # 这是 pool的返回值:>>>>16
112
    # 这是 pool的返回值:>>>>25
113
    # 这是 pool的返回值:>>>>36
114
    # 这是 pool的返回值:>>>>49
115
    # 这是 pool的返回值:>>>>64
116
    # 这是 pool的返回值:>>>>81
117
    # 这是 pool的返回值:>>>>100
118
    # 这是 pool的返回值:>>>>121
119
    # 这是 pool的返回值:>>>>144
120
    # 这是 pool的返回值:>>>>169
121
    # 这是 pool的返回值:>>>>196
122
    # 这是 pool的返回值:>>>>225
123
    # 这是 pool的返回值:>>>>256
124
    # 这是 pool的返回值:>>>>289
125
    # 这是 pool的返回值:>>>>324
126
    # 这是 pool的返回值:>>>>361
127
    # this is a main task
128

129

130

131
if __name__ == '__main__':
132
    many_steps()

【2】进阶版 2.0 - `add_done_callback(call_back)`#

add_done_callback(call_back) 返回值正是我们的上面 pool的返回的结果

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time, os
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数 的进程 : 可指定进程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个进程
14
# 这五个进程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个进程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ProcessPoolExecutor(5)
20

21

22
def task(n):
23
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
24
    time.sleep(2)
25

26
    return n * n
27

28

29
# 向池子中提交任务
30
'''
31
任务的提交方式
32
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
33
    异步：提交任务之后不等待任务的返回结果，继续执行代码
34
        返回结果如何获取？
35
            异步提交任务的返回结果 应该通过回调机制来获取
36
        异步回调机制？
37
            就相当于给每个异步任务绑定了一个定时炸弹
38
            一旦任务有结果会立即触发爆炸
39
'''
40

41

42
def call_back(n):
43
    print(f'call_back>>>:{n}')
44

45

46
def normal():
47

48
    pool.submit(task, 1)
49

50
    # 异步提交 - 先执行子线程再打印主线程
51
    print('this is a main task ')
52

53
    # 1
54
    # this is a main task
55

56

57
def many_steps():
58
    # 创建任务池子
59
    res_list = []
60
    for i in range(20):
61
        # 继续添加异步回调方法
62
        res = pool.submit(task, i).add_done_callback(call_back)
63
        print(f'这是 pool的返回值:>>>>{res}')
64
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
65
        # res_list.append(res)
66

67
    """
68
    # 关闭线程池 - 等待所有的线程池中的任务运行完毕
69
    pool.shutdown()
70
    for res in res_list:
71
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
72
        # 程序由变成了串行
73
        # res.result() ： 拿到的就是异步提交的任务的返回结果
74
        # 程序运行的结果是有序的
75

76
    print('this is a main task')
77
    """
78
    # 这是 pool的返回值:>>>>None
79
    # 这是 pool的返回值:>>>>None
80
    # 这是 pool的返回值:>>>>None
81
    # 这是 pool的返回值:>>>>None
82
    # 这是 pool的返回值:>>>>None
83
    # 这是 pool的返回值:>>>>None
84
    # 这是 pool的返回值:>>>>None
85
    # 这是 pool的返回值:>>>>None
86
    # 这是 pool的返回值:>>>>None
87
    # 这是 pool的返回值:>>>>None
88
    # 这是 pool的返回值:>>>>None
89
    # 这是 pool的返回值:>>>>None
90
    # 这是 pool的返回值:>>>>None
91
    # 这是 pool的返回值:>>>>None
92
    # 这是 pool的返回值:>>>>None
93
    # 这是 pool的返回值:>>>>None
94
    # 这是 pool的返回值:>>>>None
95
    # 这是 pool的返回值:>>>>None
96
    # 这是 pool的返回值:>>>>None
97
    # 这是 pool的返回值:>>>>None
98
    # 0 当前进程的进程号:>>>17524
99
    # 1 当前进程的进程号:>>>10136
100
    # 2 当前进程的进程号:>>>5420
101
    # 3 当前进程的进程号:>>>3932
102
    # 4 当前进程的进程号:>>>17644
103
    # call_back>>>:<Future at 0x27b365622e0 state=finished returned int>
104
    # 5 当前进程的进程号:>>>17524
105
    # 6 当前进程的进程号:>>>5420
106
    # call_back>>>:<Future at 0x27b367db370 state=finished returned int>
107
    # 7 当前进程的进程号:>>>10136
108
    # call_back>>>:<Future at 0x27b3656d3d0 state=finished returned int>
109
    # 8 当前进程的进程号:>>>3932
110
    # call_back>>>:<Future at 0x27b367db610 state=finished returned int>
111
    # 9 当前进程的进程号:>>>17644
112
    # call_back>>>:<Future at 0x27b367db760 state=finished returned int>
113
    # 10 当前进程的进程号:>>>17524
114
    # call_back>>>:<Future at 0x27b367db4f0 state=finished returned int>
115
    # 1211  当前进程的进程号:>>>5420当前进程的进程号:>>>10136
116
    #
117
    # call_back>>>:<Future at 0x27b367db910 state=finished returned int>
118
    # call_back>>>:<Future at 0x27b367dbac0 state=finished returned int>
119
    # 13 当前进程的进程号:>>>3932
120
    # call_back>>>:<Future at 0x27b367dbbb0 state=finished returned int>
121
    # call_back>>>:<Future at 0x27b367dbca0 state=finished returned int>
122
    # 14 当前进程的进程号:>>>17644
123
    # 15 当前进程的进程号:>>>17524
124
    # call_back>>>:<Future at 0x27b367dbdf0 state=finished returned int>
125
    # 16 当前进程的进程号:>>>5420
126
    # 17 当前进程的进程号:>>>10136
127
    # call_back>>>:<Future at 0x27b367e2070 state=finished returned int>
128
    # call_back>>>:<Future at 0x27b367dbf10 state=finished returned int>
129
    # 18 当前进程的进程号:>>>3932
130
    # call_back>>>:<Future at 0x27b367e2190 state=finished returned int>
131
    # 19 当前进程的进程号:>>>17644
132
    # call_back>>>:<Future at 0x27b367e22b0 state=finished returned int>
133
    # call_back>>>:<Future at 0x27b367e23d0 state=finished returned int>
134
    # call_back>>>:<Future at 0x27b367e24f0 state=finished returned int>
135
    # call_back>>>:<Future at 0x27b367e2610 state=finished returned int>
136
    # call_back>>>:<Future at 0x27b367e2730 state=finished returned int>
137
    # call_back>>>:<Future at 0x27b367e2850 state=finished returned int>
138
    #
139
    # Process finished with exit code 0
140

141

142
if __name__ == '__main__':
143
    many_steps()

【3】升级版 - 3.0#

1
# -*-coding: Utf-8 -*-
2
# @File : 06 进程池和线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
7
import time, os
8

9
# （1）线程池
10
# （1.1）参数详解
11
# 默认开设当前计算机 cpu 个数 的进程 : 可指定进程数
12
# （1.2）原理详解
13
# 池子造出来后 里面固定存在五个进程
14
# 这五个进程不会存在出现重复创建和销毁的过程
15
# （1.3）优点
16
# 避免了重复创建五个进程的资源开销
17
# （1.4）使用方法
18
# 构造好池子以后，只需要将需要做的任务向池子中提交即可
19
pool = ProcessPoolExecutor(5)
20

21

22
def task(n):
23
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
24
    time.sleep(2)
25

26
    return n * n
27

28

29
# 向池子中提交任务
30
'''
31
任务的提交方式
32
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
33
    异步：提交任务之后不等待任务的返回结果，继续执行代码
34
        返回结果如何获取？
35
            异步提交任务的返回结果 应该通过回调机制来获取
36
        异步回调机制？
37
            就相当于给每个异步任务绑定了一个定时炸弹
38
            一旦任务有结果会立即触发爆炸
39
'''
40

41

42
def call_back(n):
43
    # 这里的n是对象
44
    print(f'call_back>>>:{n}返回的结果{n.result()}')
45

46

47
def normal():
48

49
    pool.submit(task, 1)
50

51
    # 异步提交 - 先执行子线程再打印主线程
52
    print('this is a main task ')
53

54
    # 1
55
    # this is a main task
56

57

58
def many_steps():
59
    # 创建任务池子
60
    res_list = []
61
    for i in range(20):
62
        # 继续添加异步回调方法
63
        res = pool.submit(task, i).add_done_callback(call_back)
64
        print(f'这是 pool的返回值:>>>>{res}')
65
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
66
        # res_list.append(res)
67

68
    """
69
    # 关闭线程池 - 等待所有的线程池中的任务运行完毕
70
    pool.shutdown()
71
    for res in res_list:
72
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
73
        # 程序由变成了串行
74
        # res.result() ： 拿到的就是异步提交的任务的返回结果
75
        # 程序运行的结果是有序的
76

77
    print('this is a main task')
78
    """
79
    # 这是 pool的返回值:>>>>None
80
    # 这是 pool的返回值:>>>>None
81
    # 这是 pool的返回值:>>>>None
82
    # 这是 pool的返回值:>>>>None
83
    # 这是 pool的返回值:>>>>None
84
    # 这是 pool的返回值:>>>>None
85
    # 这是 pool的返回值:>>>>None
86
    # 这是 pool的返回值:>>>>None
87
    # 这是 pool的返回值:>>>>None
88
    # 这是 pool的返回值:>>>>None
89
    # 这是 pool的返回值:>>>>None
90
    # 这是 pool的返回值:>>>>None
91
    # 这是 pool的返回值:>>>>None
92
    # 这是 pool的返回值:>>>>None
93
    # 这是 pool的返回值:>>>>None
94
    # 这是 pool的返回值:>>>>None
95
    # 这是 pool的返回值:>>>>None
96
    # 这是 pool的返回值:>>>>None
97
    # 这是 pool的返回值:>>>>None
98
    # 这是 pool的返回值:>>>>None
99
    # 0 当前进程的进程号:>>>11484
100
    # 1 当前进程的进程号:>>>5068
101
    # 2 当前进程的进程号:>>>20224
102
    # 3 当前进程的进程号:>>>16524
103
    # 4 当前进程的进程号:>>>14784
104
    # 5 当前进程的进程号:>>>11484
105
    # call_back>>>:<Future at 0x1c2f98322e0 state=finished returned int>返回的结果0
106
    # 6 当前进程的进程号:>>>5068
107
    # call_back>>>:<Future at 0x1c2f983d3d0 state=finished returned int>返回的结果1
108
    # 7 当前进程的进程号:>>>20224
109
    # 8 当前进程的进程号:>>>16524
110
    # call_back>>>:<Future at 0x1c2f98ab370 state=finished returned int>返回的结果9
111
    # call_back>>>:<Future at 0x1c2f98ab3a0 state=finished returned int>返回的结果4
112
    # 9 当前进程的进程号:>>>14784
113
    # call_back>>>:<Future at 0x1c2f98ab760 state=finished returned int>返回的结果16
114
    # 10 当前进程的进程号:>>>11484
115
    # 11 当前进程的进程号:>>>5068
116
    # call_back>>>:<Future at 0x1c2f98ab580 state=finished returned int>返回的结果25
117
    # call_back>>>:<Future at 0x1c2f98ab910 state=finished returned int>返回的结果36
118
    # 12 当前进程的进程号:>>>20224
119
    # 13 当前进程的进程号:>>>16524
120
    # call_back>>>:<Future at 0x1c2f98ab940 state=finished returned int>返回的结果49
121
    # call_back>>>:<Future at 0x1c2f98abbb0 state=finished returned int>返回的结果64
122
    # 14 当前进程的进程号:>>>14784
123
    # call_back>>>:<Future at 0x1c2f98abd00 state=finished returned int>返回的结果81
124
    # 15 当前进程的进程号:>>>11484
125
    # 16 当前进程的进程号:>>>5068
126
    # call_back>>>:<Future at 0x1c2f98abdf0 state=finished returned int>返回的结果100
127
    # call_back>>>:<Future at 0x1c2f98abf40 state=finished returned int>返回的结果121
128
    # 17 当前进程的进程号:>>>16524
129
    # 18 当前进程的进程号:>>>20224
130
    # call_back>>>:<Future at 0x1c2f98b2070 state=finished returned int>返回的结果144
131
    # call_back>>>:<Future at 0x1c2f98b21c0 state=finished returned int>返回的结果169
132
    # 19 当前进程的进程号:>>>14784
133
    # call_back>>>:<Future at 0x1c2f98b22b0 state=finished returned int>返回的结果196
134
    # call_back>>>:<Future at 0x1c2f98b24f0 state=finished returned int>返回的结果256
135
    # call_back>>>:<Future at 0x1c2f98b23d0 state=finished returned int>返回的结果225
136
    # call_back>>>:<Future at 0x1c2f98b2700 state=finished returned int>返回的结果324
137
    # call_back>>>:<Future at 0x1c2f98b25e0 state=finished returned int>返回的结果289
138
    # call_back>>>:<Future at 0x1c2f98b2850 state=finished returned int>返回的结果361
139
    #
140
    # Process finished with exit code 0
141

142

143
if __name__ == '__main__':
144
    many_steps()

【4】总结#

1
# 导入模块
2
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
3

4
# 构建池子
5
pool = ProcessPoolExecutor(5)
6

7
# 提交任务
8
pool.submit(task, i).add_done_callback(call_back)

【六】协程#

进程
- 资源单位
线程
- 执行单位
协程
- 假想存在概念：单线程下实现并发的效果
- 在代码层面上监控所有的 IO 操作，一旦遇到 IO 就在代码层级完成切换
- 让CPU一直运行，没有IO，从而提升程序的运行效率
多道技术
- 切换 + 并发状态
  - 切换不一定是提升效率，也可能是降低效率
  - IO 切换：提升效率
  - 无IO 切换：降低效率
- 代码如何实现？
  - 保存上一次的执行状态，下一次继续执行
    - yield 方法（保存状态）
CPU切换的状态
- 程序遇到IO
- 程序长时间占用

【1】验证切换是否一定提升效率？#

【1】基础版 - 1.0#

最原始的计算方式：串行

1
# -*-coding: Utf-8 -*-
2
# @File : 07 协程 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
import time
7

8

9
def func1():
10
    for i in range(100000000):
11
        i += 1
12

13

14
def func2():
15
    for i in range(100000000):
16
        i += 1
17

18

19
def normal():
20
    func1()
21
    func2()
22

23

24
def main():
25
    start_time = time.time()
26
    normal()
27
    print(f'总耗时{time.time() - start_time}')
28
    # 总耗时10.284734964370728
29

30

31
if __name__ == '__main__':
32
    main()

【2】升级版 - 2.0#

切换 + yield --- 时间变长

1
# -*-coding: Utf-8 -*-
2
# @File : 07 协程 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
import time
7

8

9
def func1():
10
    while True:
11
        100000000 + 1
12
        yield
13

14

15
def func2():
16
    # 初识化迭代生成器
17
    g = func1()
18
    for i in range(100000000):
19
        i + 1
20
        # 调用迭代生成器
21
        next(g)
22

23

24
def normal():
25
    func1()
26
    func2()
27

28

29
def theGenerator():
30
    func2()
31

32

33
def main():
34
    start_time = time.time()
35
    theGenerator()
36
    print(f'总耗时{time.time() - start_time}')
37
    # 总耗时15.642895460128784
38

39

40
if __name__ == '__main__':
41
    main()

【3】增强版 - 3.0 - `gevent模块`#

基础版 - 单线程操作

1
# -*-coding: Utf-8 -*-
2
# @File : 07 协程 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
import time
7
import gevent
8

9

10
def hello_me():
11
    print(f'hello you')
12
    time.sleep(3)
13
    print(f'hello you')
14

15

16
def hello_you():
17
    print(f'hello me')
18
    time.sleep(2)
19
    print(f'hello me')
20

21

22
def run():
23
    hello_me()
24
    hello_you()
25

26

27
def main():
28
    start_time = time.time()
29
    run()
30
    print(f'总耗时{time.time() - start_time}')
31
    # hello you
32
    # hello you
33
    # hello me
34
    # hello me
35
    # 总耗时5.00632119178772
36

37

38
if __name__ == '__main__':
39
    main()

升级版 - 多线程 - 切换 IO

程序运行的时间取自运行时间最长的那个

1
# -*-coding: Utf-8 -*-
2
# @File : 07 协程 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6
import time
7
from gevent import spawn
8
from gevent import monkey
9

10
monkey.patch_all()
11

12
'''
13
gevent : 无法检测常见的 IO 操作，只能检测自己的 IO 操作
14

15
如果想检测 其他 IO 需要加上一句
16
from gevent import monkey
17
monkey.patch_all()
18

19
又由于上面的代码在使用 gevent 模块的时候是必须导入的，所以支持简写
20
from gevent import monkey;monkey.patch_all()
21

22
'''
23

24

25
def hello_me():
26
    print(f'hello you')
27
    time.sleep(3)
28
    print(f'hello you')
29

30

31
def hello_you():
32
    print(f'hello me')
33
    time.sleep(2)
34
    print(f'hello me')
35

36

37
def run():
38
    g1 = spawn(hello_me)
39
    g2 = spawn(hello_you)
40

41
    # 等待被检测的任务执行完毕再向下进行
42
    g1.join()
43
    g2.join()
44

45

46
def main():
47
    start_time = time.time()
48
    run()
49
    print(f'总耗时{time.time() - start_time}')
50

51
    # 当程序遇到 IO 时 会立马切换到没有 IO 的进程上
52
    # hello you
53
    # hello me
54
    # hello me
55
    # hello you
56
    # 总耗时3.0524613857269287
57

58

59
if __name__ == '__main__':
60
    main()

【2】协程实现 TCP 高并发效果#

服务端

1
# -*-coding: Utf-8 -*-
2
# @File : 05 进程池与线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6

7
from socket import *
8
from threading import Thread
9
from gevent import monkey
10

11
monkey.patch_all()
12
from gevent import spawn
13

14

15
def server_create(IP, PORT):
16
    server = socket()
17

18
    server.bind((IP, PORT))
19

20
    server.listen(5)
21

22
    while True:
23
        conn, addr = server.accept()
24
        spawn(conn_communication, conn)
25

26

27
def conn_communication(conn):
28
    while True:
29
        try:
30
            data = conn.recv(1024)
31
            if len(data) == 0:
32
                break
33
            print(data.decode('utf8'))
34
            conn.send(data.upper())
35
        except Exception as e:
36
            print(e)
37
            break
38
    conn.close()
39

40

41
def main():
42
    IP = '127.0.0.1'
43
    PORT = 8086
44
    g1 = spawn(server_create, IP, PORT)
45
    g1.join()
46

47

48
if __name__ == '__main__':
49
    main()

客户端

1
# -*-coding: Utf-8 -*-
2
# @File : 05 进程池与线程池 .py
3
# author: Chimengmeng
4
# blog_url : https://www.cnblogs.com/dream-ze/
5
# Time：2023/6/26
6

7
from socket import *
8
from threading import Thread, current_thread
9

10

11
def client_create(IP, PORT):
12
    count = 0
13
    client = socket()
14

15
    client.connect((IP, PORT))
16

17
    while True:
18
        msg = f'{count} is running  {current_thread().name}'
19
        count += 1
20
        client.send(msg.encode('utf8'))
21

22
        msg = client.recv(1024)
23
        print(msg.decode('utf8'))
24

25

26
def main():
27
    IP = '127.0.0.1'
28
    PORT = 8086
29
    for i in range(100)
30
        t = Thread(target=client_create, args=(IP, PORT,))
31
        t.start()
32

33

34
if __name__ == '__main__':
35
    main()

【七】总结#

我们可以通过多进程下面开设多线程
- 再通过多线程下面开设协程
达到提升程序的执行效率

音乐

音乐

【4.0】知识点小结（线程进阶）#

【一】什么是死锁与递归锁#

【1】死锁#

【2】递归锁#

【二】信号量#

【1】基础版 1.0#

【三】Event事件#

【四】线程q#

【2】`PriorityQueue`设置队列优先级#

【五】进程池与线程池#

【1】TCP实现并发的效果的原理#

【2】池的概念#

【1】什么是池？#

【2】基础版 2.0#

【3】升级版 3.0#

【4】进阶版 4.0#

【5】迭代版 5.0#

【6】增强版 6.0 - `pool.shutdown()`#

【3】进程池的使用#

【1】基础版 1.0#

【2】进阶版 2.0 - `add_done_callback(call_back)`#

【3】升级版 - 3.0#

【4】总结#

【六】协程#

【1】验证切换是否一定提升效率？#

【1】基础版 - 1.0#

【2】升级版 - 2.0#

【3】增强版 - 3.0 - `gevent模块`#

【2】协程实现 TCP 高并发效果#

【七】总结#

支持与分享

音乐

线程进阶知识点小结

【4.0】知识点小结（线程进阶）#

【一】什么是死锁与递归锁#

【1】死锁#

【2】递归锁#

【二】信号量#

【1】基础版 1.0#

【三】Event事件#

【四】线程q#

【2】PriorityQueue设置队列优先级#

【五】进程池与线程池#

【1】TCP实现并发的效果的原理#

【2】池的概念#

【1】什么是池？#

【2】基础版 2.0#

【3】升级版 3.0#

【4】进阶版 4.0#

【5】迭代版 5.0#

【6】增强版 6.0 - pool.shutdown()#

【3】进程池的使用#

【1】基础版 1.0#

【2】进阶版 2.0 - add_done_callback(call_back)#

【3】升级版 - 3.0#

【4】总结#

【六】协程#

【1】验证切换是否一定提升效率？#

【1】基础版 - 1.0#

【2】升级版 - 2.0#

【3】增强版 - 3.0 - gevent模块#

【2】协程实现 TCP 高并发效果#

【七】总结#

支持与分享

【2】`PriorityQueue`设置队列优先级#

【6】增强版 6.0 - `pool.shutdown()`#

【2】进阶版 2.0 - `add_done_callback(call_back)`#

【3】增强版 - 3.0 - `gevent模块`#