初学Python——进程

2018-07-29 08:48:28来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

什么是进程?

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

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

线程和进程的区别:

进程是资源的集合,进程要在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 multiprocessing
import threading
import time

def t_run():
    print("线程号",threading.get_ident()) # 线程id


def 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 multiprocessing


def 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, Pool
import 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可以很方便的同时自动处理几百或者上千个并行操作,脚本的复杂性也大大降低.

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:连续加班一周最终把所有的Python库整理出来了,愿各位早日学会Py

下一篇:9大Python最常用的数据分析库,在2018都做了哪些更新?