标签：队列 current 之间 roc 公司 就是 sop lap import
生产消费者模型(必须要理解并且牢记,默写内容):
from multiprocessing import Process,Queue import time,random,os def procducer(q): for i in range(10): res=‘包子%s‘ %i time.sleep(0.5) q.put(res) print(‘%s 生产了 %s‘ %(os.getpid(),res)) def consumer(q): while True: res=q.get() if res is None: break print(‘%s 吃 %s‘ %(os.getpid(),res)) time.sleep(random.randint(2,3)) if __name__ == ‘__main__‘: q=Queue() p=Process(target=procducer,args=(q,)) c=Process(target=consumer,args=(q,)) p.start() c.start() p.join() q.put(None) print(‘主‘)
今日概要:
1 守护进程vs守护线程（*）
2 互斥锁（**）
3 信号量（**）
4 生产者消费者模型（*****）
5 GIL（什么时候用进程，什么时候用线程）（*****） ===========>这里明天讲
守护进程和守护线程:
# #守护进程 # from multiprocessing import Process # import os,time,random # # def task(): # print(‘%s is running‘ %os.getpid()) # time.sleep(2) # print(‘%s is done‘ %os.getpid()) # # p = Process(target=time.sleep, args=(3,)) # # p.start() # # if __name__ == ‘__main__‘: # p=Process(target=task) # p.daemon = True #1、必须在p.start()之前 2：守护进程不能开启子进程 # p.start() # # p.join() # print(‘主‘) # # ‘‘‘ # 举例说明守护进程的应用场景： # 假设有两个任务要干，要玩出并发的效果，使用进程的话可以让主进程 # 执行一个任务，然后开启一个子进程执行一个任务。 # # 如果这两个任务毫无关系，那么就像上面这么做就可以 # 如果主进程的任务在执行完毕后，子进程的任务没有存在的意义了 # 那么该子进程应该在开启之前就被设置成守护进程 # ‘‘‘ #迷惑人的例子 #主进程代码运行完毕,守护进程就会结束 # from multiprocessing import Process # 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__‘: # p1=Process(target=foo) # p2 = Process(target=bar) # # p1.daemon=True # p1.start() # p2.start() # print("main-------") #打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止 # # # #守护线程：等到该进程内所有非守护线程都运行完才死掉 # from multiprocessing import Process # from threading import Thread # import os,time,random # # def task(): # # t=Thread(target=time.sleep,args=(3,)) # # t.start() # print(‘%s is running‘ %os.getpid()) # time.sleep(2) # print(‘%s is done‘ %os.getpid()) # # if __name__ == ‘__main__‘: # t=Thread(target=task) # t.daemon = True #1、必须在t.start()之前 # t.start() # # t.join() # print(‘主‘) #迷惑人的例子 #主进程代码运行完毕,守护进程就会结束 from multiprocessing import Process 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-------") ‘‘‘ 123 456 main------- end123 end456 ‘‘‘
理解补充:
这里的的意思就是:我们要开启守护进程,开启的方式要在start之前开启,然后用固定格式开启,
# 开启之后的结果就是,守护进程是等待主进程执行完了自己的代码之后就会挂掉,至于主进程里面的其他的子进程就不考虑了,
# 即便那些子进程还没有执行完成我们也不会去继续执行了,程序到主进程执行完成后就结束了,这里就是守护进程的作用.
# 至于他的应用场景,就是在实现并发的情况下,我们在主进程里面需要开启其他的进程来帮助我们执行任务,这些任务彼此之间是有关联的,
# 我们只需要在主进程执行完后就不需要其他的子进程继续去执行了,这个时候我们的子进程就需要被设置为守护进程
互斥锁--------进程:
from multiprocessing import Process,Lock import os,time,random def task(mutex): mutex.acquire() print(‘%s print 1‘ %os.getpid()) time.sleep(random.randint(1,3)) print(‘%s print 2‘ %os.getpid()) time.sleep(random.randint(1, 3)) print(‘%s print 3‘ %os.getpid()) mutex.release() if __name__ == ‘__main__‘: # p1=Process(target=task) # p2=Process(target=task) # p3=Process(target=task) # p1.start() # p1.join() # p2.start() # p2.join() # p3.start() # p3.join() mutex=Lock() p1=Process(target=task,args=(mutex,)) p2=Process(target=task,args=(mutex,)) p3=Process(target=task,args=(mutex,)) p1.start() p2.start() p3.start()
锁进程的时候,当主进程执行完毕后,守护进程立即挂掉,即便此时还有没有执行完了子进程也不会去执行了,整个程序立即结束
互斥锁-------------线程:
from threading import Thread,Lock import time n=100 def task(): # global n # mutex.acquire() # temp=n # time.sleep(0.1) # n=temp-1 # mutex.release() global n with mutex: temp=n time.sleep(0.1) n=temp-1 if __name__ == ‘__main__‘: mutex=Lock() 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)
线程里面有两种情况,如果主线程执行完了此时守护线程还没有完,就会立即挂掉,但是,如果主线程已经完了,守护线程还没有完,那么它作为守护线程也会挂掉.
这里有一个例子,可以加深对于锁的理解:
from multiprocessing import Process,Lock import json import os import time import random # import json # with open(‘db.txt‘,‘w‘,encoding=‘utf-8‘) as f: # json.dump({‘count‘:1},f) # 在程序运行前先运行一下这上面的三行代码 def search(): with open(‘db.txt‘,encoding=‘utf-8‘) as f: dic=json.load(f) print(‘%s 剩余票数 %s‘ %(os.getpid(),dic[‘count‘])) def get(): with open(‘db.txt‘,encoding=‘utf-8‘) as read_f: dic=json.load(read_f) if dic[‘count‘] > 0: dic[‘count‘]-=1 time.sleep(random.randint(1,3)) #模拟手速+网速 with open(‘db.txt‘,‘w‘,encoding=‘utf-8‘) as write_f: json.dump(dic,write_f) print(‘%s 抢票成功‘ %os.getpid()) def task(mutex): search() mutex.acquire() get() mutex.release() if __name__ == ‘__main__‘: # for i in range(20): # p=Process(target=task) # p.start() # p.join() mutex = Lock() for i in range(10): p = Process(target=task, args=(mutex, )) p.start()
信号量(理解即可,不必深究):
from multiprocessing import Process,Semaphore # from threading import Thread,Semaphore import time,random,os def task(sm): with sm: print(‘%s 上厕所‘ %os.getpid()) time.sleep(random.randint(1,3)) if __name__ == ‘__main__‘: sm=Semaphore(3) for i in range(10): p=Process(target=task,args=(sm,)) p.start() # 这里是信号量,它跟进程池就是多了一个锁的概念,资源抢占,相当于是在一个公司里有很多# 人要干活, # 每个人的分工不同,大家平日里都是各做各的事情,但是大家都会牵扯到使用打印机的情况,当大家都扎堆使用打印机的时候, # 这里就牵扯到了信号量的概念,打印机只有3个,但是使用它的人却源源不断理解到这即可
队列,堆栈,优先级:
from multiprocessing import Queue #进程队列 # q=Queue(3) # # q.put({‘a‘:1}) # q.put(‘xxxxx‘) # q.put(3) # q.put(4) # print(q.get()) # print(q.get()) # print(q.get()) # print(q.get()) import queue #线程队列 #队列 # q=queue.Queue(3) # q.put({‘a‘:1}) # q.put(‘xxxxx‘) # q.put(3) # q.put(4) # print(q.get()) # print(q.get()) # print(q.get()) # print(q.get()) #优先级队列 # q=queue.PriorityQueue(3) # q.put((10,{‘a‘:1})) # q.put((-1,‘xxxxx‘)) # q.put((0,3)) # # q.put(4) # # print(q.get()) # print(q.get()) # print(q.get()) # print(q.get()) #堆栈 # q=queue.LifoQueue(3) # q.put({‘a‘:1}) # q.put(‘xxxxx‘) # q.put(3) # # q.put(4) # # print(q.get()) # print(q.get()) # print(q.get()) # print(q.get())
# #pip install requests
# import requests
# from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# from threading import current_thread
# import time
# import os
#
# def get(url):
# print(‘%s GET %s‘ %(os.getpid(),url))
# response=requests.get(url)
# time.sleep(3)
# if response.status_code == 200:
# return {‘url‘:url,‘text‘:response.text}
#
# def parse(obj):
# res=obj.result()
# print(‘[%s] <%s> (%s)‘ % (os.getpid(), res[‘url‘],len(res[‘text‘])))
#
# if __name__ == ‘__main__‘:
# urls = [
# ‘https://www.python.org‘,
# ‘https://www.baidu.com‘,
# ‘https://www.jd.com‘,
# ‘https://www.tmall.com‘,
# ]
# # t=ThreadPoolExecutor(2)
# t=ProcessPoolExecutor(2)
# for url in urls:
# t.submit(get,url).add_done_callback(parse)
# t.shutdown(wait=True)
#
# print(‘主‘,os.getpid())
# ‘‘‘
# 异步调用：
# 提交完任务（为该任务绑定一个回调函数），不用再原地等任务执行完毕拿到结果，可以直接提交下一个任务
# 一个任务一旦执行完毕就会自动触发回调函数的运行
#
# 回调函数的参数是单一的：
# 回调函数的参数就是它所绑定任务的返回值
#
# ‘‘‘
#pip install requests
import requests
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread
import time
import os
def get(url):
print(‘%s GET %s‘ %(current_thread().getName(),url))
response=requests.get(url)
time.sleep(3)
if response.status_code == 200:
return {‘url‘:url,‘text‘:response.text}
def parse(obj):
res=obj.result()
print(‘[%s] <%s> (%s)‘ % (current_thread().getName(), res[‘url‘],len(res[‘text‘])))
if __name__ == ‘__main__‘:
urls = [
‘https://www.python.org‘,
‘https://www.baidu.com‘,
‘https://www.jd.com‘,
‘https://www.tmall.com‘,
]
t=ThreadPoolExecutor(2)
for url in urls:
t.submit(get,url).add_done_callback(parse)
t.shutdown(wait=True)
print(‘主‘,os.getpid())
标签：队列 current 之间 roc 公司 就是 sop lap import
原文地址：http://www.cnblogs.com/2012-dream/p/7979555.html
