Process实例有2个重要属性：name和pid

Process实例的方法

#导入模块
import multiprocessing
import time

#定义进程执行函数
def clock(interval):
	for i in range(5):
		print('当前时间为{0}： '.format(time.ctime()))
		time.sleep(interval)

if __name__=='__main__':
	#创建子进程
	p=multiprocessing.Process(target=clock,args=(1,))
	#启动子进程
	p.start()
	p.join()
	#获取进程的 ID
	print('p.id:',p.pid)
	#获取进程的名称
	print('p.name:',p.name)
	#判断进程是否运行
	print('p.is_alive:',p.is_alive())

创建多个进程

执行不同的任务

#导入模块
import multiprocessing
import time

#创建进程调用函数
def work1(interval):
	print('执行work1')
	time.sleep(interval)
	print('end work1')

def work2(interval):
	print('执行work2')
	time.sleep(interval)
	print('end work2')

def work3(interval):
	print('执行work3')
	time.sleep(interval)
	print('end work3')

if __name__=='__main__':
	print('执行主进程')
	#创建进程对象
	p1=multiprocessing.Process(target=work1,args=(4,))
	p2=multiprocessing.Process(target=work2,args=(3,))
	p3=multiprocessing.Process(target=work3,args=(2,))
	#启动进程
	p1.start()
	p2.start()
	p3.start()
	p1.join()
	p2.join()
	p3.join()
	print('主进程结束')

继承process类创建进程

      像Java一样，也有2种方式创建进程

      创建进程的方式还可以使用类的方式，可以自定义一个类，继承 Process 类，重写run方法，每次实例化这个类的时候，就等同于实例化一个进程对象
 

#导入模块
from multiprocessing import Process
import time

#定义线程类
class ClockProcess(Process):
	def __init__(self,interval):
		Process.__init__(self)
		self.interval=interval
	def run(self):
		print('子进程开始执行的时间:{}'.format(time.ctime()))
		time.sleep(self.interval)
		print('子进程结束的时间:{}'.format(time.ctime()))

if __name__=='__main__':
	#创建子进程
	p=ClockProcess(2)
	#调用子进程
	p.start()
	p.join()
	print('主进程结束')

进程池

      在利用 Python 进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing 中的 Process 动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。

      Pool 可以提供指定数量的进程，供用户调用，当有新的请求提交到 pool 中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程。

Pool（numprocess, initializer, initargs）

      其中 numprocess 是要创建的进程数。如果省略此参数，将使用 cpu_count()的值。cpu是4核，就创建有4个进程的进程池，8核就创建8个进程的进程池

      Initializer是每个工作进程启动时要执行的可调用对象。 Initargs 是要传递给 initializer 的参数元祖。

      Initializer 默认为 None

import multiprocessing
import time

def func(msg):
	print("start:", msg)
	time.sleep(3)
	print("end： ",msg)

if __name__ == "__main__":
	pool = multiprocessing.Pool(processes = 3)
	for i in range(5):
		msg = "任务%d" %(i)
		#维持执行的进程总数为 processes，当一个进程执行完毕后会添加新的进程进去
		pool.apply_async(func, (msg, ))
	pool.close()#进程池关闭之后不再接收新的请求
	#调用 join 之前，先调用 close 函数，否则会出错。
	# 执行完 close 后不会有新的进程加入到 pool,join 函数等待所有子进程结束
	pool.join()

apply_async 是在一个池工作进程中异步地执行函数（*args， **kwargs），然后返回结果

apply是在一个池工作进程中执行函数（*args， **kwargs），然后返回结果。
 

这是使用apply执行线程池的线程的

import multiprocessing
import time

def func(msg):
	print("start:", msg)
	time.sleep(3)
	print("end",msg)

if __name__ == "__main__":
	pool = multiprocessing.Pool(processes = 3)
	for i in range(5):
		msg = "任务%d" %(i)
		#维持执行的进程总数为 processes，当一个进程执行完毕后会添加新的进程进去
		pool.apply(func, (msg, ))
	pool.close()
	#调用 join 之前，先调用 close 函数，否则会出错。
	# 执行完 close 后不会有新的进程加入到 pool,join 函数等待所有子进程结束
	pool.join()