---恢复内容开始---

一、多进程

  1、multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似。

import time
from multiprocessing import Process
def func(name):
print('%s 函数开始,time:%s' %(name,time.ctime()))
# time.sleep(2)
print('%s 函数结束,time:%s' %(name,time.ctime())) if __name__ == "__main__":
p1=Process(target=func,args=('one',))
p2=Process(target=func,args=('two',))
p3=Process(target=func,args=('three',))
p4=Process(target=func,args=('four',))
p5 = Process(target=func, args=('five',))
p1.start()
p2.start()
p3.start()
p4.start()
p5.start()
print(u'主进程%s'%time.ctime())
结果:
one 函数开始,time:Sat Sep 08 17:15:40 2018
two 函数开始,time:Sat Sep 08 17:15:40 2018
主进程Sat Sep 08 17:15:40 2018
three 函数开始,time:Sat Sep 08 17:15:40 2018
four 函数开始,time:Sat Sep 08 17:15:40 2018
five 函数开始,time:Sat Sep 08 17:15:40 2018
one 函数结束,time:Sat Sep 08 17:15:42 2018
two 函数结束,time:Sat Sep 08 17:15:42 2018
three 函数结束,time:Sat Sep 08 17:15:42 2018
four 函数结束,time:Sat Sep 08 17:15:42 2018
five 函数结束,time:Sat Sep 08 17:15:42 2018  

  *所有函数并发执行(注意:在windows中Process()必须放到# if __name__ == '__main__':下#方法二(和上面效果一样)

import time
from multiprocessing import Process class Piao(Process):
def __init__(self,name):
Process.__init__(self)
self.name=name
def run(self):
print('%s 函数开始,time:%s' %(self.name,time.ctime()))
time.sleep(2)
print('%s 函数结束,time:%s' %(self.name,time.ctime())) if __name__ == '__main__':
p1=Piao('one')
p2=Piao('two')
p3=Piao('three')
p4=Piao('four')
    #p.daemon = True(进程守护和线程守护一样)
p1.start()
p2.start()
    p3.start()
p4.start()
print('主线程%s'%time.ctime())

   2、join()方法是用来让主进程等待所有子进程结束并不影响子进程之间的并发:

import time
from multiprocessing import Process
class Piao(Process):
def __init__(self,name):
Process.__init__(self)
self.name=name
def run(self):
print('%s 函数开始,time:%s' %(self.name,time.ctime()))
time.sleep(2)
print('%s 函数结束,time:%s' %(self.name,time.ctime()))
if __name__ == '__main__':
tasks = []
tasks.append(Piao('one'))
tasks.append(Piao('two'))
tasks.append(Piao('three'))
tasks.append(Piao('four'))
for p in tasks:
p.start()
for p in tasks:
p.join()
print('主线程%s'%time.ctime())
结果:
one 函数开始,time:Sat Sep 08 17:37:43 2018
two 函数开始,time:Sat Sep 08 17:37:43 2018
three 函数开始,time:Sat Sep 08 17:37:43 2018
four 函数开始,time:Sat Sep 08 17:37:43 2018
one 函数结束,time:Sat Sep 08 17:37:45 2018
two 函数结束,time:Sat Sep 08 17:37:45 2018
three 函数结束,time:Sat Sep 08 17:37:45 2018
four 函数结束,time:Sat Sep 08 17:37:45 2018
主线程Sat Sep 08 17:37:45 2018 #主进程等所有子进程结束,子进程之间并不影响并发

  

  5、进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争,竞争带来的结果就            是错乱,如何控制,就是加锁处理

#并发运行,效率高,但竞争同一打印终端,带来了打印错乱
#由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import os,time
def work(lock):
lock.acquire()
print('%s 函数开始,time:%s' %(os.getpid(),time.ctime()))
time.sleep(2)
print('%s 函数结束,time:%s' %(os.getpid(),time.ctime()))
lock.release()
if __name__ == '__main__':
lock=Lock()
for i in range(3):
p=Process(target=work,args=(lock,))
p.start()
24464 函数开始,time:Sat Sep 08 18:02:17 2018
24464 函数结束,time:Sat Sep 08 18:02:19 2018
21072 函数开始,time:Sat Sep 08 18:02:19 2018
21072 函数结束,time:Sat Sep 08 18:02:21 2018
13536 函数开始,time:Sat Sep 08 18:02:21 2018
13536 函数结束,time:Sat Sep 08 18:02:23 2018

之前打印是同一时间,是多个进程共享同一打印终端,但是加了锁后就不能共享了,但是依旧是并发,是锁限制了共享终端,在读写文件是需要枷锁,不然容易造成错乱

6、队列

   Queue([maxsize]):创建共享的进程队列,Queue是多进程安全的队列,常用来在生产者和消费者线程之间的信息传递。queue.put方法用以插入数据到队列中,queue.get方法用来冲数据队列去除数据(先进先出)

产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

 

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
while True:
res=q.get()
if res in None: break
time.sleep(random.randint(1,3))
print('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res)) def producer(q):
for i in range(20):
time.sleep(random.randint(1,3))
res='包子%s' %i
q.put(res)
print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))
q.put(None) if __name__ == '__main__':
q=Queue()
#生产者
p1=Process(target=producer,args=(q,))
#消费者
c1=Process(target=consumer,args=(q,))
#开始
p1.start()
c1.start()
print('主进程')

7、进程池

Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,就重用进程池中的进程。

from multiprocessing import Pool
import os,time
def work(n):
print('%s run,time:%s' %(os.getpid(),time.ctime()))
time.sleep(3)
return n**2 if __name__ == '__main__':
p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
res_l=[]
for i in range(10):
res=p.apply_async(work,args=(i,)) #同步运行,阻塞、直到本次任务执行完毕拿到res
res_l.append(res) #异步apply_async用法:如果使用异步提交的任务,主进程需要使用jion,等待进程池内任务都处理完,然后可以用get收集结果,否则,主进程结束,进程池可能还没来得及执行,也就跟着一起结束了
p.close()
p.join()
for res in res_l:
print res.get(), #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get,‘,’无须换行打印
结果:
6684 run,time:Mon Sep 10 11:41:22 2018
732 run,time:Mon Sep 10 11:41:22 2018
10748 run,time:Mon Sep 10 11:41:22 2018
6684 run,time:Mon Sep 10 11:41:25 2018
732 run,time:Mon Sep 10 11:41:25 2018
10748 run,time:Mon Sep 10 11:41:25 2018
6684 run,time:Mon Sep 10 11:41:28 2018
732 run,time:Mon Sep 10 11:41:28 2018
10748 run,time:Mon Sep 10 11:41:28 2018
6684 run,time:Mon Sep 10 11:41:31 2018
0 1 4 9 16 25 36 49 64 81
 #进程池最大容量设置三,因此每次只有三个异步进程执行,等待执行结束再安排

---恢复内容结束---

python多线程和多进程(二)的更多相关文章

  1. Python 多线程、多进程 (二)之 多线程、同步、通信

    Python 多线程.多进程 (一)之 源码执行流程.GIL Python 多线程.多进程 (二)之 多线程.同步.通信 Python 多线程.多进程 (三)之 线程进程对比.多线程 一.python ...

  2. Python 多线程、多进程 (三)之 线程进程对比、多进程

    Python 多线程.多进程 (一)之 源码执行流程.GIL Python 多线程.多进程 (二)之 多线程.同步.通信 Python 多线程.多进程 (三)之 线程进程对比.多线程 一.多线程与多进 ...

  3. Python 多线程、多进程 (一)之 源码执行流程、GIL

    Python 多线程.多进程 (一)之 源码执行流程.GIL Python 多线程.多进程 (二)之 多线程.同步.通信 Python 多线程.多进程 (三)之 线程进程对比.多线程 一.python ...

  4. Python多线程和多进程谁更快?

    python多进程和多线程谁更快 python3.6 threading和multiprocessing 四核+三星250G-850-SSD 自从用多进程和多线程进行编程,一致没搞懂到底谁更快.网上很 ...

  5. python多线程与多进程--存活主机ping扫描以及爬取股票价格

    python多线程与多进程 多线程: 案例:扫描给定网络中存活的主机(通过ping来测试,有响应则说明主机存活) 普通版本: #扫描给定网络中存活的主机(通过ping来测试,有响应则说明主机存活)im ...

  6. python多线程与多进程及其区别

    个人一直觉得对学习任何知识而言,概念是相当重要的.掌握了概念和原理,细节可以留给实践去推敲.掌握的关键在于理解,通过具体的实例和实际操作来感性的体会概念和原理可以起到很好的效果.本文通过一些具体的例子 ...

  7. 基于Windows平台的Python多线程及多进程学习小结

    python多线程及多进程对于不同平台有不同的工具(platform-specific tools),如os.fork仅在Unix上可用,而windows不可用,该文仅针对windows平台可用的工具 ...

  8. python基础之多线程与多进程(二)

    上课笔记整理: 守护线程的作用,起到监听的作用 一个函数连接数据库 一个做守护线程,监听日志 两个线程同时取一个数据 线程---->线程安全---->线程同时进行操作数据. IO操作--- ...

  9. python多线程,多进程

    线程是公用内存,进程内存相互独立 python多线程只能是一个cpu,java可以将多个线程平均分配到其他cpu上 以核为单位,所以GIL(全局锁,保证线程安全,数据被安全读取)最小只能控制一个核,很 ...

  10. python 多线程和多进程

    多线程与多进程 知识预览 一 进程与线程的概念 二 threading模块 三 multiprocessing模块 四 协程 五 IO模型 回到顶部 一 进程与线程的概念 1.1 进程 考虑一个场景: ...

随机推荐

  1. Objective-C NSString/NSMutableString

    创建于完成: 2018/02/05 总览: http://www.cnblogs.com/lancgg/p/8404975.html  字符串类  简介  字符码: Unicode  NSString ...

  2. IP地址简单入门

    ------------------------针对网络地址相关的小白,最快速接触网络知识------------------------- 可以使用python自带的模块IPy,进行处理IP地址或I ...

  3. c语言程序设计案例教程(第2版)笔记(三)—变量、结构体

    零散知识点: 变量        :C语言中,每个变量必须先定义后引用.所谓变量存在是指系统为这个变量分配一块存储空间,此时对变量的操作,就是对变量所对应的存储空间中存放的数据进行操作.人们将变量占据 ...

  4. jQuery查找

    导航查找方法: 向下查找兄弟标签: $().next() $().nextAll() 向上查找兄弟标签: 可以查找所有兄弟标签: 查找子标签 查找父级标签: $().parent() $().pare ...

  5. Python variable 作用域和初始化

    Python 根据LEGB rule在不同的namespace中找变量 在def的函数中对global 变量做修改还是不推荐的,应该将其作为参数传入函数 try: do_something() cnt ...

  6. 1354 选数字 DP背包 + 数学剪枝

    http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1354&judgeId=187448 其实这题和在若干个数字中,选 ...

  7. 微信打开网址添加在浏览器中打开提示 http://caibaojian.com/weixin-tip.html

    原文链接:http://caibaojian.com/weixin-tip.html#t2 使用微信打开网址时,无法在微信内打开常用下载软件,手机APP等.网上流传的各种微信打开下载链接,微信已更新基 ...

  8. 移动web开发基础(二)——viewport

    本文主要研究为什么移动web开发需要设置viewport,且一般设置为<meta name="viewport" content="width=device-wid ...

  9. java 缓冲流 Buffer

    缓冲流 Buffer :设置缓冲区加快执行效率 子类: (一)BufferedInputStream : 缓冲输入字节流 ,目的:提高读取文件的效率  注意: BufferedInputStream ...

  10. LN : leetcode 712 Minimum ASCII Delete Sum for Two Strings

    lc 712 Minimum ASCII Delete Sum for Two Strings 712 Minimum ASCII Delete Sum for Two Strings Given t ...