进程、线程补充与协程相关介绍

补充点

1.死锁

当你知道锁的使用抢锁必须要释放锁，其实你在操作锁的时候也极其容易产生死锁现象(整个程序卡死 阻塞)

1. from threading import Thread, Lock
2. import time
5. mutexA = Lock()
6. mutexB = Lock()
7. # 类只要加括号多次 产生的肯定是不同的对象
8. # 如果你想要实现多次加括号等到的是相同的对象 单例模式
11. class MyThead(Thread):
12.     def run(self):
13.         self.func1()
14.         self.func2()
16.     def func1(self):
17.         mutexA.acquire()
18.         print('%s 抢到A锁'% self.name)  # 获取当前线程名
19.         mutexB.acquire()
20.         print('%s 抢到B锁'% self.name)
21.         mutexB.release()
22.         mutexA.release()
23.         
24.     def func2(self):
25.         mutexB.acquire()
26.         print('%s 抢到B锁'% self.name)
27.         time.sleep(2)
28.         mutexA.acquire()
29.         print('%s 抢到A锁'% self.name)  # 获取当前线程名
30.         mutexA.release()
31.         mutexB.release()
34. if __name__ == '__main__':
35.     for i in range(10):
36.         t = MyThead()
37.         t.start()

复制代码

2.递归锁

递归锁的特点：

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

1. # 代码只需要将上述死锁的
2. mutexA = Lock()
3. mutexB = Lock()
4. # 换成
5. mutexA = mutexB = RLock()
6. # 这样死锁的程序就可以正常运行下去

复制代码

3.信号量

信号量在不同阶段可能对应不同的技术点，在并发编程中，信号量指的是锁！！
信号量与互斥锁的比较：信号量可以看成是多个坑位，互斥锁只能是一个坑位！！
信号量的具体语法：

1. from threading import Thread, Semaphore  # 信号量的模块
2. import time,random
4. sm = Semaphore(5)  # 表示同时开设5个坑位（互斥锁只开设一个）
6. def task(name):
7.     sm.acquire()  # 加锁
8.     print('%s正在蹲坑'%name)
9.     time.sleep(random.randint(1,3))  # 蹲坑时间不等
10.     sm.release()  # 释放锁
12. if __name__ == '__main__':
13.     for i in range(20):  # 20个人去抢5个厕所
14.         t = Thread(target=task,args=(i,))
15.         t.start()

复制代码

4.Event事件

主进程/线程等待子进程/线程运行结束时，我们使用的是join方法！
而需要子进程/线程之间的相互的等待结束，需要用到event事件

1. from threading import Thread,Event
2. import time
4. # 1.先产生一个event对象
5. event = Event()
7. def person():
8.     print('你来了')
9.     time.sleep(2)
10.     event.set()  # 2.发送信号，表示我执行完毕了，你可以结束了
12. def my():
13.     event.wait()  # 3.接收到信号，好的我开始执行
14.     print('我走了')
16. if __name__ == '__main__':
17.     t = Thread(target=person)
18.     t1 = Thread(target=my)
19.     t1.start()
20.     t.start()

复制代码

5.进程池和线程池(重要掌握)

5.1 什么是池？

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

5.2 线程池的使用

1. # 1.导入进程池/线程池模块
2. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
3. import time
5. # 2.创建一个线程池对象，该对象括号内不传参数，默认是开设当前cpu个数*5的线程
6. pool = ThreadPoolExecutor(5) # 传入参数5，表示池子里固定创建了5个线程，这5个线程不会重复创建和销毁
8. def task(name):
9.     print('%s来了'% name)
10.     time.sleep(2)
12. # 3.朝池子中提交任务，第一个参数是函数名，第二个参数是函数需要传入的参数
13. """
14. 同步提交：提交任务之后原地等待返回结果，不往下执行任务
15. 异步提交：提交任务之后不原地等待返回结果，继续往下执行
16. """
17. # pool.submit(task,'zhang') # 注意：这里的提交是一个异步提交
18. # print('主')
20. # 优化
21. list = []
22. for i in range(20): # 向池子中提交20个任务。池子中只有5个线程
23.     res = pool.submit(task,i)  # 池方法异步提交之后有一个返回值，该返回值是一个future对象
24.     # print(res.result())  # 该对象有一个result方法，可以用来返回对应线程函数的返回值，没有返回值则返回none
25.     # result方法的使用使得submi异步提交变成了同步提交
26.     list.append(res)
27. # 如果想等待所有的线程全部执行完毕，在往下执行代码，可以使用池的shutdown方法
28. pool.shutdown() # shutdown的作用是等待所有线程池运行完毕，再关闭所有线程池往下运行
29. for i in list:
30.     print(i.result())

复制代码

5.3 进程池的使用

基本同线程池,不同的是以下部分：

1. # 1.导入进程池/线程池模块
2. from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
3. import time,os
5. pool = ProcessPoolExecutor(5)  # 不传默认是cpu的个数
7. def task(name):
8.     print('%s来了'% name)
9.     time.sleep(2)
11. # call_back函数里面需要传一个参数，该参数就是res（一个future对象）
12. def call_back(n):
13.     # 可以通过n.result()的方法获取task函数的返回值
14.     print(n.result())
16. if __name__ == '__main__':
17.     for i in range(20):
18.         # add_done_callback方法是给submit这个异步提交添加一个回调机制，完成任务之后立刻回调结果，方法的参数是一个函数
19.         res = pool.submit(task, i).add_done_callback(call_back)

复制代码

协程

1.什么是协程

协程其实就是一种在单线程下实现并发的操作，程序猿通过检测自己写的代码，一旦遇到了IO操作的代码，我们就编写代码进行切换，这样使得cpu一直处于运行状态，提高程序的运行效率！
2.协程的具体写法

gevent模块的引用时为了使得函数之间不断的切换+保存状态！！

1. """
2. 使用协程，就必须要我们通过代码实时检测程序是否进入到了IO操作，如果进入了IO操作，
3. 就进行快速的切换，以此来实现并发的效果，提升程序的运行效率
4. """
5. # 1.导入gevent模块的spawn模块，该模块是用来监测函数里面的IO操作的，但是spawn模块是无法监测一些常见的IO操作的
6. # 因此，需要导入gevent模块中的monkey模块，以此来监测所有的IO操作
7. from gevent import monkey,spawn
8. monkey.patch_all()  # 猴子补丁
9. import time
11. def func1():
12.     print('hhh')
13.     time.sleep(2)
14.     print('lalala')
16. def func2():
17.     print('wwww')
18.     time.sleep(3)
19.     print('结束')
21. start_time = time.time()
22. g1 = spawn(func1) # spawn括号里是需要启动监测的函数名，函数名后面可以加需要传入的参数
23. g2 = spawn(func2) # 该方法是异步提交，有一个返回值，如果没有join方法会自动往下执行代码，结束程序
24. g2.join() # 等待函数执行完在往下执行
25. g1.join()
26. print(time.time()-start_time)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！