初学Python——进程

什么是进程？

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

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

线程和进程的区别：

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