首页 > > 网络编程 > 其它 >

初学Python——进程

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

什么是进程？

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

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

线程和进程的区别：

进程是资源的集合，进程要在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可以很方便的同时自动处理几百或者上千个并行操作，脚本的复杂性也大大降低.