python 多进程 每个进程做不同功能实例_进程，线程，以及Python的多进程实例

什么是进程，什么是线程？

进程与线程是包含关系，进程包含了线程。

进程是系统资源分配的最小单元，线程是系统任务执行的最小单元。

打个比方，打开word，word这个程序是一个进程，里面的拼写检查，字数统计，更改字体等等功能是一个个线程。当word这个进程启动的时候，系统分配给word进程一些资源(CPU，内存等)，当某个线程执行时需要资源时，就从word进程的资源池里取。

关于Python的多进程实例，我们可以用Python的multiprocessing package来实现。

multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：

from multiprocessing importProcessimportos#子进程要执行的代码

defrun_proc(name):print('Run child process %s (%s)...' %(name, os.getpid()))if __name__=='__main__':print('Parent process %s.' %os.getpid())

p= Process(target=run_proc, args=('test',))print('Child process will start.')

p.start()

p.join()print('Child process end.')

执行结果:

Parent process 928.

Process will start.

Run child process test (929)...

Process end.

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

如果要启动大量的子进程，可以用进程池的方式批量创建子进程：

from multiprocessing importPoolimportos, time, randomdeflong_time_task(name):print('Run task %s (%s)...' %(name, os.getpid()))

start=time.time()

time.sleep(random.random()* 3)

end=time.time()print('Task %s runs %0.2f seconds.' % (name, (end -start)))if __name__=='__main__':print('Parent process %s.' %os.getpid())

p= Pool(4)for i in range(5):

p.apply_async(long_time_task, args=(i,))print('Waiting for all subprocesses done...')

p.close()

p.join()print('All subprocesses done.')

执行结果如下：

Parent process 669.

Waitingforall subprocesses done...

Run task 0 (671)...

Run task1 (672)...

Run task2 (673)...

Run task3 (674)...

Task2 runs 0.14seconds.

Run task4 (673)...

Task1 runs 0.27seconds.

Task3 runs 0.86seconds.

Task 0 runs1.41seconds.

Task4 runs 1.91seconds.

All subprocesses done.

代码解读： 对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成p=Pool(5)，就可以跑5个进程

子进程

很多时候，子进程并不是自身，而是一个外部进程。我们创建了子进程后，还需要控制子进程的输入和输出。

subprocess模块可以让我们非常方便地启动一个子进程，然后控制其输入和输出。

下面的例子演示了如何在Python代码中运行命令nslookup www.python.org，这和命令行直接运行的效果是一样的：

importsubprocessprint('$ nslookup www.python.org')

r= subprocess.call(['nslookup', 'www.python.org'])print('Exit code:', r)

运行结果：

$ nslookup www.python.org

Server:192.168.19.4Address:192.168.19.4#53

Non-authoritative answer:

www.python.org canonical name=python.map.fastly.net.

Name: python.map.fastly.net

Address:199.27.79.223Exit code: 0

如果子进程还需要输入，则可以通过communicate()方法输入：

importsubprocessprint('$ nslookup')

p= subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

output, err= p.communicate(b'set q=mx\npython.org\nexit\n')print(output.decode('utf-8'))print('Exit code:', p.returncode)

上面的代码相当于在命令行执行命令nslookup，然后手动输入：

set q=mx

python.org

exit

运行结果如下：

$ nslookup

Server:192.168.19.4Address:192.168.19.4#53

Non-authoritative answer:

python.org mail exchanger= 50mail.python.org.

Authoritative answers can be foundfrom:

mail.python.org internet address= 82.94.164.166mail.python.org has AAAA address2001:888:2000:d::a6

Exit code: 0

进程间通信

Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing importProcess, Queueimportos, time, random#写数据进程执行的代码:

defwrite(q):print('Process to write: %s' %os.getpid())for value in ['A', 'B', 'C']:print('Put %s to queue...' %value)

q.put(value)

time.sleep(random.random())#读数据进程执行的代码:

defread(q):print('Process to read: %s' %os.getpid())whileTrue:

value=q.get(True)print('Get %s from queue.' %value)if __name__=='__main__':#父进程创建Queue，并传给各个子进程：

q =Queue()

pw= Process(target=write, args=(q,))

pr= Process(target=read, args=(q,))#启动子进程pw，写入:

pw.start()#启动子进程pr，读取:

pr.start()#等待pw结束:

pw.join()#pr进程里是死循环，无法等待其结束，只能强行终止:

pr.terminate()

运行结果如下：

Process to write: 50563Put A to queue...

Process to read:50564Get Afromqueue.

Put B to queue...

Get Bfromqueue.

Put C to queue...

Get Cfrom queue.

在Unix/Linux下，multiprocessing模块封装了fork()调用，使我们不需要关注fork()的细节。由于Windows没有fork调用，因此，multiprocessing需要“模拟”出fork的效果，父进程所有Python对象都必须通过pickle序列化再传到子进程去，所有，如果multiprocessing在Windows下调用失败了，要先考虑是不是pickle失败了。