博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
初学Python——进程
阅读量:5838 次
发布时间:2019-06-18

本文共 4260 字,大约阅读时间需要 14 分钟。

什么是进程?

  程序不能单独执行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的过程就叫做进程。进程是操作系统调度的最小单位。

  程序和进程的区别在于:程序是储存在硬盘上指令的有序集合,是静态的;进程是内存中程序的一次执行过程,属于动态概念。

线程和进程的区别:

进程是资源的集合,进程要在CPU执行,必须要创建线程,至少要有一个线程在运行。

  1.线程共享创建它的进程的地址空间。进程的内存空间是独立的。

  2.线程可以直接访问其进程的数据段(不同线程共享同一个进程的数据),进程间不共享。

  3.线程可以与其他线程进行通信,进程必须使用进程间通信(中间代理)与同级进程进行通信。

  4.新的线程很容易创建,新的进程需要父进克隆。

  5.线程可以直接操作和控制同一进程内的其它线程,而进程只能操作子进程。

  6.对主线程的修改可能会影响到其它线程的行为。对父进程的修改不会影响子进程(不删除父进程的前提下)

 Python多进程的使用

Process 类用来描述一个进程对象。创建子进程的时候,只需要传入一个执行函数和函数的参数即可完成 Process 示例的创建。

  star() 方法启动进程。

  join() 方法实现进程间的同步,等待所有进程退出。

  close() 用来阻止多余的进程涌入进程池 Pool 造成进程阻塞。

multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

  target 是函数名字,需要调用的函数

  args 函数需要的参数,以 元组 的形式传入

 multiprocessing模块的使用跟线程类似

import multiprocessingimport threadingimport timedef t_run():    print("线程号",threading.get_ident()) # 线程iddef run(name):    time.sleep(1)    print('hello', name)    t = threading.Thread(target=t_run)    t.start()if __name__ == '__main__':    for i in range(10):        p = multiprocessing.Process(target=run, args=(i,))        p.start()
multiprocessing

所有的进程都是由父进程启动的,所以发现此程序的父进程ID正是PyCharm。

每个进程都是相互独立的,存在于不同的内存地址。

进程间通信

  • 首先声明一点,这里所说的进程间通信指的是父子进程之间的通信机制。如果两个进程间没有关系,这里的机制是无法奏效的。
  • 通信方式有:进程队列Queue、管道通信Pipe、共享数据Manger

1.进程队列Queue

  进程队列直接使用multiprocessing模块的Queue类,不同于线程队列的queue模块。

import multiprocessingdef f(q):    q.put([42, None, 'hello'])    q.put(30)if __name__ == '__main__':    q = multiprocessing.Queue()    p = multiprocessing.Process(target=f, args=(q,)) # 将队列copy一份传给子进程    p.start()    print(q.get())  # 在父进程中取出队列中数据    print(type(q.get()))    p.join()
进程队列

2.管道Pipe

  两个进程在管道两边收发数据。

import multiprocessing'''Pipe管道实例,两个进程在管道两边收发数据'''def f(conn):    conn.send([42, None, 'hello'])  # 发送数据    print("child_conn接收:",conn.recv())   # 接收数据    conn.close()def s(conn):    conn.send("你好,紫禁城")  # 发送数据    print("parent_conn接收:",conn.recv())   # 接收数据    conn.close()if __name__ == '__main__':    parent_conn, child_conn = multiprocessing.Pipe() # 管道实例,连接着两个进程    p = multiprocessing.Process(target=f, args=(child_conn,))    p2 = multiprocessing.Process(target=s,args=(parent_conn,))    p.start()    p2.start()    #print(parent_conn.recv())          # 父进程接收管道的数据    #parent_conn.send("你好,紫禁城")   # 父进程发送数据    p.join()    p2.join()
Pipe

3.进程间共享数据Manger

  使用Manger()可以创建共享的数据,包括列表,字典,元组等多种类型。

from multiprocessing import Process, Manager  def f(d, l):    d[1] = '1'    d['2'] = 2    d[0.25] = None    l.append(1)    print(l)  if __name__ == '__main__':    with Manager() as manager:        d = manager.dict()          l = manager.list(range(5))        p_list = []        for i in range(10):            p = Process(target=f, args=(d, l))            p.start()            p_list.append(p)        for res in p_list:            res.join()          print(d)        print(l)
Manger

Lock

  屏幕锁,防止一个进程未打印完毕,另一个进程插入

def f(l,i):    l.acquire()    print("hello",i)    l.release()if __name__ == '__main__':    l=Lock()    for i in range(10):        Process(target=f,args=(l,i)).start()
lock

进程池

在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间。当被操作对象数目不大时,可以直接利用multiprocessing中的Process动态成生多个进程,10几个还好,但如果是上百个,上千个目标,手动的去限制进程数量却又太过繁琐,这时候进程池Pool发挥作用的时候就到了。

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

from multiprocessing import Process, Poolimport time, os  def Foo(i):    time.sleep(5)    print('in process[Foo]', os.getpid())    return i + 100  def Bar(arg):  # 父进程去执行,而不是子进程调用    print('-->exec done:', arg)    print('in process[Bar]', os.getpid())  if __name__ == '__main__':    pool = Pool(5)  # 允许进程池里同时放入5个进程 其他多余的进程处于挂起状态     for i in range(10):        pool.apply_async(func=Foo, args=(i,), callback=Bar)          # pool.apply(func=Foo, args=(i,))       print('end:', os.getpid())    pool.close()  # close() 必须在join()前被调用    pool.join()   # 进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
进程池
  • pool.apply_async()用来向进程池提交目标请求。
  • pool.join()是用来等待进程池中的worker进程执行完毕,防止主进程在worker进程结束前结束。但pool.join()必须使用在pool.close()或者pool.terminate()之后。
  • close()terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。
  • result.successful()表示整个调用执行的状态,如果还有worker没有执行完,则会抛出AssertionError异常。    
  • 利用multiprocessing下的Pool可以很方便的同时自动处理几百或者上千个并行操作,脚本的复杂性也大大降低.

 

转载地址:http://wfncx.baihongyu.com/

你可能感兴趣的文章
我的友情链接
查看>>
linux(centos)搭建SVN服务器
查看>>
fai2ban防暴力破解
查看>>
成功申请到ClickDealer联盟
查看>>
Ngx_http-headers_module
查看>>
strcpy ,strncpy ,strlcpy特点
查看>>
结合业务特性巧用临时表
查看>>
Monkey测试简介
查看>>
mongodb 对内存的严重占用以及解决办法
查看>>
azkaban2.5安装
查看>>
华为SSL ***配置
查看>>
CentOS6.4系统启动失败故障排查An error occurred during the file sytem check
查看>>
我的友情链接
查看>>
TypeScript介绍视频
查看>>
windows 8体验有感
查看>>
龙年春晚王菲颤音发挥失常,哈文称现场声音返送没问题
查看>>
公司部分区域的网络搬迁
查看>>
我的友情链接
查看>>
Redhat 7安装samba服务后只能读取目录,无法写入的处理办法
查看>>
Linux里的特殊权限之a和i
查看>>