Python入门学习-DAY35-线程
一、进程补充
1.进程间通信(IPC机制)
进程间通讯有两种方法：管道或者队列。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来。
from multiprocessing import Queue q=Queue(3)#3是队列允许存在的个数 q.put('1') q.put('2') q.put('3') print(q.get(block=True,timeout=2)) print(q.get()) print(q.get())
block默认是True，意思是可以阻塞。timeout是阻塞时间，阻塞时间到了会报错
那么什么情况下会阻塞：
1.当限制队列里的数量时，放入超过限制的消息，会阻塞，等待第一个放入的被取走，才会继续执行
2.当限制队列里的数量时，取出超过限制的消息，因为此时的队列是空的，只有队列里再次放入内容时才会继续执行
2.生产者消费者模型
1. 什么是生产者消费者模型
生产者:代指生产数据的任务
消费者:代指处理数据的任务
该模型的工作方式:
生产生产数据传递消费者处理
实现方式:
生产者---->队列<------消费者
2. 为何要用
当程序中出现明细的两类任务,一类负责生产数据,一类负责处理数据
就可以引入生产者消费者模型来实现生产者与消费者的解耦合,平衡生产能力与消费能力,从提升效率
3. 如何用
from multiprocessing import Process,Queue import time,random def producer(name,food,p): for i in range(3): res='%s%s'%(food,i) time.sleep(random.randint(1,3)) print('%s生产了%s'%(name,res)) p.put(res) def customer(name,p): while True: res=p.get() if res is None:break#判断消费者是否消费完，如果消费完，就会取到NONE time.sleep(random.randint(1,3)) print('%s吃了%s'%(name,res)) if __name__ == '__main__': p=Queue() p1=Process(target=producer,args=('1','葱油拌屎',p,)) p2 = Process(target=producer, args=('2', '手抓屎', p,)) p3 = Process(target=producer, args=('3', '飘香拌屎', p,)) c1=Process(target=customer,args=('姚晓锋',p,)) c2 = Process(target=customer, args=('阿飞', p,)) p1.start() p2.start() p3.start() c1.start() c2.start() p1.join() p2.join() p3.join()#说明此时生产者已经生产完了 p.put(None)#有几个消费者就加上几个NONE p.put(None) c1.join() c2.join() print('主')
from multiprocessing import Process,JoinableQueue import time,random def producer(name,food,p): for i in range(3): res='%s%s'%(food,i) time.sleep(random.randint(1,3)) print('%s生产了%s'%(name,res)) p.put(res) def customer(name,p): while True: res=p.get() time.sleep(random.randint(1,3)) print('%s吃了%s'%(name,res)) if __name__ == '__main__': p=JoinableQueue() p1=Process(target=producer,args=('1','葱油拌屎',p,)) p2 = Process(target=producer, args=('2', '手抓屎', p,)) p3 = Process(target=producer, args=('3', '飘香拌屎', p,)) c1=Process(target=customer,args=('姚晓锋',p,)) c2 = Process(target=customer, args=('阿飞', p,)) c1.daemon=True c2.daemon=True p1.start() p2.start() p3.start() c1.start() c2.start() p1.join() p2.join() p3.join() p.join()#主进程等待队列里为空 #一旦队列为空，说明消费者取完了队列，消费者没有价值了 print('主')
二、线程理论
1 什么是线程
进程其实一个资源单位,而进程内的线程才是cpu上的执行单位
线程其实指的就是代码的执行过程
2 为何要用线程
线程的优点
1. 同一进程下的多个线程共享该进程内的资源
2. 创建线程的开销要远远小于进程
三、开启线程的两种方式
线程开启的方式与进程一致
from threading import Thread import time def task(name): print('%s is running'%name) time.sleep(3) print('%s is done'%name) if __name__ == '__main__': p=Thread(target=task,args=('yxf',)) p.start() print('主')
from threading import Thread import time class Mythread(Thread): def __init__(self,name): super().__init__() self.name=name def run(self): print('%s is running'%self.name) time.sleep(3) print('%s is done'%self.name) if __name__ == '__main__': p=Mythread('egon') p.start() print('主')
四、线程特性介绍
Thread实例对象的方法
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
threading模块提供的一些方法
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
同一进程下的线程共享资源
from threading import Thread,current_thread,active_count n=100 def task(): global n n=0 print('子进程n=',n,current_thread()) if __name__ == '__main__': p1=Thread(target=task,) p1.start() print(active_count()) p1.join() print(active_count()) print('主进程n=',n,current_thread())
五、守护线程
守护线程的生命周期取决于被守护线程（主线程）的生命周期，但是主线程要等到非守护线程都结束执行才会执行完毕
也就是说，只有非守护线程都执行完毕，守护线程才会结束
from threading import Thread import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(3) print("end456") if __name__ == '__main__': t1=Thread(target=foo) t2=Thread(target=bar) t1.daemon=True t1.start() t2.start() print("main-------")
六、线程互斥锁
与进程一致
from threading import Thread,Lock import time mutex=Lock() n=100 def task(): global n mutex.acquire() temp=n time.sleep(0.1) n=temp-1 mutex.release() if __name__ == '__main__': t_l=[] for i in range(100): t=Thread(target=task) t_l.append(t) t.start() for t in t_l: t.join() print(n)
