生产消费者模型(必须要理解并且牢记,默写内容):

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()
if response.status_code == :
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()
for url in urls:
t.submit(get,url).add_done_callback(parse)
t.shutdown(wait=True) print('主',os.getpid())

day 34 编程之补充内容的更多相关文章

  1. [.NET] 《Effective C#》快速笔记 - C# 高效编程要点补充

    <Effective C#>快速笔记 - C# 高效编程要点补充 目录 四十五.尽量减少装箱拆箱 四十六.为应用程序创建专门的异常类 四十七.使用强异常安全保证 四十八.尽量使用安全的代码 ...

  2. JAVA第十周《网络编程》学习内容总结

    JAVA第十周<网络编程>学习内容总结 学习内容总结 1.初听到网络编程四个字可能会觉得很困难,实际上网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据,把数据发送到指定的位置, ...

  3. 《Effective C#》快速笔记(六)- - C# 高效编程要点补充

    目录 四十五.尽量减少装箱拆箱 四十六.为应用程序创建专门的异常类 四十七.使用强异常安全保证 四十八.尽量使用安全的代码 四十九.实现与 CLS 兼容的程序集 五十.实现小尺寸.高内聚的程序集 这是 ...

  4. Java学习笔记16(面向对象九:补充内容)

    总是看到四种权限,这里做一个介绍: 最大权限是public,后面依次是protected,default,private private修饰的只在本类可以使用 public是最大权限,可以跨包使用,不 ...

  5. Python学习---JSON补充内容[中文编码 + dumps解析]

    JSON补充内容[微信解决中文乱码,接上] import json # 英文显示 dic = {"hello": "world"} str = json.dum ...

  6. JVM 专题五:类加载子系统(三)补充内容

    3. 补充内容 3.1 在jvm中表示两个class对象是否为同一个类的两个必要条件 类的完整类名必须一致,包括包名. 加载这个类的ClassLoader(指ClassLoader实例对象)必须相同 ...

  7. 【浅墨著作】《OpenCV3编程入门》内容简单介绍&amp;amp;勘误&amp;amp;配套源码下载

    经过近一年的沉淀和总结,<OpenCV3编程入门>一书最终和大家见面了. 近期有为数不少的小伙伴们发邮件给浅墨建议最好在博客里面贴出这本书的文件夹,方便大家更好的了解这本书的内容.事实上近 ...

  8. 企业架构研究总结(34)——TOGAF架构内容框架之架构制品(下)

    4.2.31 数据生命周期图(Data Lifecycle Diagram) 数据生命周期图是在业务流程的约束之下对业务数据在其整个生命周期(从概念阶段到最终退出)中对其进行管理的核心部分.数据从本质 ...

  9. python基础编程: 编码补充、文件操作、集合、函数参数、函数递归、二分查找、匿名函数与高阶函数

    目录: 编码的补充 文件操作 集合 函数的参数 函数的递归 匿名函数与高阶函数 二分查找示例 一.编码的补充: 在python程序中,首行一般为:#-*- coding:utf-8 -*-,就是告诉p ...

随机推荐

  1. ElasticSearch入门系列(三)文档,索引,搜索和聚合

    一.文档 在实际使用中的对象往往拥有复杂的数据结构 Elasticsearch是面向文档的,这意味着他可以存储整个对象或文档,然而他不仅仅是存储,还会索引每个文档的内容使之可以被搜索,在Elastic ...

  2. java Channel filp compact

    import java.nio.ByteBuffer; //Listing 7-1. Copying Bytes from an Input Channel to an Output Channel ...

  3. 转:装完Centos7提示Initial setup of CentOS Linux 7 (core)

    在用U盘装完CentOS后,重新开机启动后显示: Initial setup of CentOS Linux 7 (core) 1) [x] Creat user 2) [!] License inf ...

  4. sccm部署win7原版系统系统盘为D盘

    1. 系统部署完毕之后是这样的

  5. Python-Day7 面向对象进阶/异常处理/Socket

    一.面向对象高级语法部分 1.静态方法     通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里 ...

  6. Windows下Nginx的安装与使用(一):配置端口转发

    什么是端口转发 当我们在服务器上搭建一个图书以及一个电影的应用,其中图书应用启动了 8001 端口,电影应用启动了 8002 端口.此时如果我们可以通过: localhost:8001 //图书 lo ...

  7. CCF系列之Z字形扫描(201412-2)

    试题编号:201412-2试题名称:Z字形扫描时间限制: 2.0s内存限制: 256.0MB 问题描述 在图像编码的算法中,需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan).给定一个n ...

  8. thinkphp5引入公共部分header、footer等

    由于用惯了tp3.2,改用tp5有些还是感觉别扭的 直接上问题:项目中需要用到引入公共导航.头部.底部.右边部分等等 首先要弄清楚thinkphp5的配置项是哪个文件,众所周知:config.php, ...

  9. ImageMagick 转换图片格式

    [root@ drawable-hdpi-v4]# convert ic_launcher.jpeg ic_launcher.png [root@ drawable-hdpi-v4]# file ic ...

  10. JS操作DOM节点大全

    1.Javascript删除节点 在Javascript中,只提供了一种删除节点的方法:removeChild(). removeChild() 方法用来删除父节点的一个子节点. 语法:parent. ...