Python之进程

什么是进程程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行...

什么是进程

　　程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。在多道编程中，我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU，因此，进程就是为了在CPU上实现多道编程而提出的。

多道程序设计技术

　　所谓多道程序设计技术，就是指允许多个程序同时进入内存并运行。即同时把多个程序放入内存，并允许它们交替在CPU中运行，它们共享系统中的各种硬、软件资源。当一道程序因I/O请求而暂停运行时，CPU便立即转去运行另一道程序。

多进程

实例（可以循环生成多个子进程）

from multiprocessing import Process

def f(name):
    print('hello', name)
 
if __name__ == '__main__':
    p = Process(target=f, args=('bob',))  #生成一个子进程
    p.start()　　　　　　　　　　　　　　　　　 #启动一个子进程　　　
    p.join()　　　　　　　　　　　　　　　　　　#等待子进程的执行结束

多进程间的通讯

　　由于多进程与多线程不同，多线程是处在同一个进程之间，所以多线程之间的内存是共享的，他们可以修改同一个内存中的数据，可以相互之间达到内存共享。但是多进程则不同，多进程之间由于内存独立，所以数据之间不能直接共享，那么我们如何实现多进程之间的通讯呢？

一、Queue队列

from multiprocessing import Queue,Process

def func(a):
    print('这是子进程：',a.get())

if __name__ == '__main__':
    q = Queue()
    q.put(123)
    p = Process(target=func,args=(q,))
    p.start()

运行结果：
>>这是子进程： 123

　　进程Queue和线程queue的使用方法基本一致，但是我们在父进程中放入Queue中的数据可以在子进程中拿出（反之也可以），这种方法实现了进程间的数据传递。

二、Pipes管道

from multiprocessing import Process,Pipe
def func(n):
    print(n.recv())
    n.send('from son')

if __name__ == '__main__':
    f,s = Pipe()
    p = Process(target=func,args=(s,))
    p.start()
    f.send('from father')
    print(f.recv())

　　实例化管道之后，会返回两个对象，也就是管道的两端，将一端留在父进程，一端作为参数传入给子进程，然后可以通过send和recv方法接收和发送数据，以达到不同进程间的通信。

三、Managers

from multiprocessing import Process,Manager
import os

def func(a,b):
    a[os.getpid()] = os.getpid()
    b.append(os.getpid())

if __name__ == '__main__':
    manager = Manager()
    d = manager.dict()
    l = manager.list()
    l2 = []
    for i in range(10):
        p = Process(target=func,args=(d,l))
        p.start()
        l2.append(p)
    for i in l2:
        i.join()

# os.getpid()是获得当前进程的id，os.getppid()是获得当前父进程的id

　　实例化manager之后。通过manager来生成字典，列表等等，将其传给子进程，通过这些数据格式来实现不同进程间的通讯。A manager returned by  Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. 

进程锁

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

　　有人说，线程之间加锁是为了避免数据混乱，进程之间内存都已经不共享了，为什么还要加锁呢？如果多个进程同时占有对方需要的资源而同时请求对方的资源，而它们在得到请求之前不会释放所占有的资源，那么就会导致死锁的发生，也就是进程不能实现同步。举个例子就是竞争资源，如当系统中供多个进程共享的资源如打印机、公用队列等，其数目不足以满足进程的需要时，会引起诸进程的竞争而产生死锁。

进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中的方法：

• apply　　                      从进程池里取一个进程并同步执行     
• apply_async　　           从进程池里取出一个进程并异步执行
• terminate                       立刻关闭进程池
• join                                主进程等待所有子进程执行完毕，必须在close或terminete之后
• close                             等待所有进程结束才关闭线程池

from  multiprocessing import Pool
import time,os

def Foo(i):
    time.sleep(2)
    print('进程：',os.getpid())
    return 'ok'               #return的值被回调函数接收

def Bar(arg):
    print('-->该子进程执行完毕:', arg,os.getpid())     #由执行结果可以发现回调函数由父进程执行而不由子进程执行          

if __name__ == '__main__':
    print('父进程：',os.getpid())
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=Foo, args=(i,), callback=Bar)          #程序异步执行，也就是并行，Bar为回调函数，可以没有
        # pool.apply(func=Foo, args=(i,))　　　　　　　　　#如果执行这种方法，程序会变成同步执行，也就是串行　　
    pool.close()
    pool.join()  　　　　　　# 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

父进程： 904
进程： 12232
-->exec done: ok 904
进程： 14396
-->exec done: ok 904
进程： 16736
-->exec done: ok 904
进程： 17276
-->exec done: ok 904
进程： 2908
-->exec done: ok 904
进程： 12232
-->exec done: ok 904
进程： 14396
-->exec done: ok 904
进程： 16736
-->exec done: ok 904
进程： 17276
-->exec done: ok 904
进程： 2908
-->exec done: ok 904