码迷,mamicode.com
首页 > 其他好文 > 详细

第三十五天

时间:2018-09-10 17:58:47      阅读:281      评论:0      收藏:0      [点我收藏+]

标签:thread   取出   port   管道   生产者与消费者   之间   []   star   glob   

进程间通行=>IPC 管道 队列=管道+锁 import subprocess subprocess.Popen(‘tasklist’,shell=True)开子进程结果往终端里面丢 开进程,子进程和父进程彼此之间没有影响 队列先进先出 from multiprocessing import Queue    导入一个队列Queue

q=Queue()   队列的大小 q.put([‘first‘,]) put存放 q.put({‘x‘:2}) q.put(3) q.put(4)

print(q.get())    get取出 print(q.get()) print(q.get()) print(q.get()) 结果: [‘first‘] {‘x‘: 2} 3 4

from multiprocessing import Queue

q=Queue(3) q.put([‘first‘,],block=True,timeout=3)(block队列满的时候锁的意思默认是True) q.put({‘x‘:2},block=True,timeout=3)(timeout代表阻的时间三秒) q.put(3,block=True,timeout=3) q.put(4,block=True,timeout=3) block=True,timeout=-1 意思是如果阻住了一直等   q.put_nowait(1) #q.put(1,block=False)(不阻了,没有等候时间) q.put_nowait(2) q.put_nowait(3) q.put_nowait(4)到第四个会报错

print(q.get(block=True,timeout=3)) print(q.get(block=True,timeout=3)) print(q.get(block=True,timeout=3)) print(q.get(block=True,timeout=3)) 前面三个没有意义,到了第四个阻塞住了才有意义 print(q.get_nowait()) #q.get(block=false)(没有阻塞时间) print(q.get_nowait()) #q.get(block=false) print(q.get_nowait()) #q.get(block=false) print(q.get_nowait()) #q.get(block=false)(不等直接报错)

生产者消费者模型: 生产者和消费者中间加入一个介质,俩个不是互相沟通,而是互相像介质沟通 1. 什么是生产者消费者模型     生产者:代指生产数据的任务     消费者:代指处理数据的任务     该模型的工作方式:         生产生产数据传递消费者处理

        实现方式:             生产者---->队列<------消费者

2. 为何要用     当程序中出现明细的两类任务,一类负责生产数据,一类负责处理数据     就可以引入生产者消费者模型来实现生产者与消费者的解耦合,平衡生产能力与消费能力,从提升效率

举例: import time,random from multiprocessing import Process,Queue

def producer(name,food,q):    生产者     for i in range(3):         res=‘%s%s‘ %(food,i)         time.sleep(random.randint(1,3)) #模拟生产数据的时间         q.put(res)         print(‘厨师[%s]生产了<%s>‘ %(name,res))

def consumer(name,q):     消费者     while True:         res=q.get()             if res is None:break   生产者给消费者发结束信号 ,消费者收到就结束         time.sleep(random.randint(1,3)) #模拟处理数据的时间         print(‘吃货[%s]吃了<%s>‘ %(name,res))

if __name__ == ‘__main__‘:     q=Queue()     # 生产者们     p1=Process(target=producer,args=(‘小Egon‘,‘泔水‘,q))     p2=Process(target=producer,args=(‘中Egon‘,‘屎包子‘,q))     p3=Process(target=producer,args=(‘大Egon‘,‘腰子汤‘,q))     # 消费者们     c1=Process(target=consumer,args=(‘刘清正‘,q))     c2=Process(target=consumer,args=(‘吴三江‘,q))

    p1.start()     p2.start()     p3.start()     c1.start()     c2.start()

    p1.join()     p2.join()     p3.join()     q.put(None) #q.put_nowait(None)(放在队列的最后面,一个消费者用一个,所以用俩)     q.put(None)     print(‘主‘) 结果: 厨师[大Egon]生产了<腰子汤0> 厨师[小Egon]生产了<泔水0> 厨师[中Egon]生产了<屎包子0> 吃货[吴三江]吃了<腰子汤0> 厨师[大Egon]生产了<腰子汤1> 吃货[吴三江]吃了<屎包子0> 吃货[刘清正]吃了<泔水0> 厨师[中Egon]生产了<屎包子1> 厨师[小Egon]生产了<泔水1> 厨师[大Egon]生产了<腰子汤2> 厨师[小Egon]生产了<泔水2> 厨师[中Egon]生产了<屎包子2> 主 吃货[吴三江]吃了<腰子汤1> 吃货[刘清正]吃了<屎包子1> 吃货[刘清正]吃了<腰子汤2> 吃货[吴三江]吃了<泔水1> 吃货[吴三江]吃了<屎包子2> 吃货[刘清正]吃了<泔水2>

了解: import time,random from multiprocessing import Process,JoinableQueue

def producer(name,food,q):     for i in range(3):         res=‘%s%s‘ %(food,i)         time.sleep(random.randint(1,3)) #模拟生产数据的时间         q.put(res)         print(‘厨师[%s]生产了<%s>‘ %(name,res))

def consumer(name,q):     while True:         res=q.get()         time.sleep(random.randint(1,3)) #模拟处理数据的时间         print(‘吃货[%s]吃了<%s>‘ %(name,res))         q.task_done()   消费者发信号说取走了一个,接着可以做减法操作

if __name__ == ‘__main__‘:     q=JoinableQueue()    ()     # 生产者们     p1=Process(target=producer,args=(‘小Egon‘,‘泔水‘,q))     p2=Process(target=producer,args=(‘中Egon‘,‘屎包子‘,q))     p3=Process(target=producer,args=(‘大Egon‘,‘腰子汤‘,q))     # 消费者们  把消费者做成守护进程     c1=Process(target=consumer,args=(‘刘清正‘,q))     c2=Process(target=consumer,args=(‘吴三江‘,q))     c1.daemon=True          c2.daemon=True

    p1.start()     p2.start()     p3.start()     c1.start()     c2.start()

    p1.join()  主进程等p1结束在执行下一个代码     p2.join()     p3.join()     q.join() # 主进程等q结束,即q内数据被取干净了     print(‘主‘)

结果: 厨师[大Egon]生产了<腰子汤0> 厨师[小Egon]生产了<泔水0> 厨师[中Egon]生产了<屎包子0> 厨师[大Egon]生产了<腰子汤1> 吃货[吴三江]吃了<泔水0> 厨师[小Egon]生产了<泔水1> 厨师[中Egon]生产了<屎包子1> 吃货[刘清正]吃了<腰子汤0> 厨师[小Egon]生产了<泔水2> 厨师[中Egon]生产了<屎包子2> 厨师[大Egon]生产了<腰子汤2> 吃货[吴三江]吃了<屎包子0> 吃货[刘清正]吃了<腰子汤1> 吃货[吴三江]吃了<泔水1> 吃货[刘清正]吃了<屎包子1> 吃货[吴三江]吃了<泔水2> 吃货[刘清正]吃了<屎包子2> 吃货[吴三江]吃了<腰子汤2> 主

 

线程理论 1 什么是线程     进程其实一个资源单位,而进程内的线程才是cpu上的执行单位     线程其实指的就是代码的执行过程

2 为何要用线程     线程vs进程         1. 同一进程下的多个线程共享该进程内的资源         2. 创建线程的开销要远远小于进程    开启线程的俩种方式 第一种方式: from threading import Thread import time

def task(name):     print(‘%s is running‘ %name)     time.sleep(2)     print(‘%s is done‘ %name)

if __name__ == ‘__main__‘:     t=Thread(target=task,args=(‘线程1‘,))     t.start()     print(‘主‘) 结果: 线程1 is running 主 线程1 is done 第二种方式: from threading import Thread import time

class Mythread(Thread):     def run(self):         print(‘%s is running‘ %self.name)         time.sleep(2)         print(‘%s is done‘ %self.name)

if __name__ == ‘__main__‘:     t=Mythread()     t.start()     print(‘主‘) 结果: Thread-1 is running 主 Thread-1 is done

守护线程: from threading import Thread import time

def task(name):     print(‘%s is running‘ %name)     time.sleep(2)     print(‘%s is done‘ %name)

if __name__ == ‘__main__‘:     t=Thread(target=task,args=(‘线程1‘,))     t.daemon=True     t.start()     print(‘主‘) 结果: 线程1 is running 主

from threading import Thread from multiprocessing import Process 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=Process(target=foo)     t2=Process(target=bar)     t1.daemon=True     t1.start()     t2.start()     print("main-------") 会出现的几种结果 #     ‘‘‘ #     123 #     main------- #     456 #     end456 #     ‘‘‘ # #     ‘‘‘ #     main------- #     123 #     456 #     end456 #     ‘‘‘ # #     ‘‘‘ #     main------- #     456 #     end456 #     ‘‘‘

线程互斥锁 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) 结果:0

线程特性介绍 from threading import Thread,active_count,current_thread import time,os

def task():     print(‘%s is running‘ %current_thread().name)     time.sleep(2)

if __name__ == ‘__main__‘:     t=Thread(target=task,)     t.start()     t.join()     print(‘主‘,active_count())     print(‘主‘,current_thread().name) 结果 : Thread-1 is running 主 1 主 MainThread

from threading import Thread import time,os

def task():     print(‘%s is running‘ %os.getpid())

if __name__ == ‘__main__‘:     t=Thread(target=task)     t.start()     print(‘主‘,os.getpid()) 结果: 8924 is running 主 8924

from threading import Thread import time

n=100 def task():     global n     n=0

if __name__ == ‘__main__‘:     t=Thread(target=task)     t.start()     t.join()     print(‘主‘,n) 结果: 主 0

 

第三十五天

标签:thread   取出   port   管道   生产者与消费者   之间   []   star   glob   

原文地址:https://www.cnblogs.com/zhouhao123/p/9621142.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!