Python—创建进程的三种方式

方式一：os.fork()

• 子进程是从os.fork得到的值，然后赋值开始执行的。即子进程不执行os.fork，从得到的值开始执行。
• 父进程中fork之前的内容子进程同样会复制，但父子进程空间独立，fork之后的修改不会影响到对方。
• 父子进程在执行上互不影响，谁先执行，谁先执行完不确定。
• 父子进程之间相互独立，全局变量，局部变量都互不影响。
• 父进程执行完就结束，子进程会继续执行。主进程不会因为子进程没结束而等待。
• 子进程虽然复制父进程的空间，但是有自己的特性，比如自己的PID，进程PCB，进程栈空间等。

单个fork

import os, time

g_num = 100
ret = os.fork()   # 父进程得到的ret的值等于子进程的pid。子进程得到的ret的值等于0。

if ret < 0:
    print "---创建一级子进程失败---"
elif ret == 0:
    print "---子进程的pid：%d" % os.getpid()
    g_num += 1
else:
    print "---父进程的pid：%d" % os.getpid()
    while True:
        time.sleep(3)
        break
print "进程执行完毕", g_num      # 父进程打印结果为：100，子进程打印结果为：101

多个fork

import os,time

# 父进程执行下面的fork
ret = os.fork()
if ret==0:
    print("--1--")   # 子进程
else:
    print("--2--")   # 父进程

# 父子进程都执行下面的fork，即父子进程都创建了子进程，此时共有四个进程
ret = os.fork()
if ret==0:
    print("--11--")
else:
    print("--22--")

方式二：multiprocessing.Process()

• 子进程执行的函数结束，子进程就结束了。父进程等待子进程结束后才退出。
• 子进程修改全局变量或者局部变量，对父进程没有丝毫影响。
• 父进程执行完不退出，子进程会继续执行。父进程等待子进程结束后才退出。

# --coding:utf8--
from multiprocessing import Process
import os,time,random

def test(num, msg):
    print "---子进程的pid=%d, ppid=%d, num=%d, msg=%s" % (os.getpid(), os.getppid(), num, msg)
    for i in range(random.randint(1, 5)):
        print("----%d---"%i)
        time.sleep(1)

# p = Process(target=test, args=(), kwargs={})   # 当函数没有参数时候，可以这样写
p = Process(target=test, args=(100,), kwargs={"msg":"hello"})
p.start() # 让这个进程开始执行test函数里的代码
p.join()  # 堵塞，可以加参数p.join(1)。等到p这个对象标记的进程结束之后，才会继续向下走

print "---父进程的pid=%d" % os.getpid()

方式三：继承multiprocessing.Process类

from multiprocessing import Process
import os, time

# 自定义的进程类
class MyProcess(Process):
	def __init__(self, value):
		self.value = value
		Process.__init__(self)
		# super(MyProcess,self).__init__()

    # 在自定义的进程类中重写父类(Process)的run()方法
	def run(self):
		print "---子进程：%s开始执行，父进程pid：%s"%(os.getpid(),os.getppid())
		while True:
			print("---传的参数值为：%d---" % self.value)
			time.sleep(1)

if __name__ == '__main__':
	p = MyProcess(3)
	p.start()
	p.join(6)   # 阻塞等到子进程执行结束，超时时间为6秒。不加参数，会一直阻塞等待下去。
	while True:
	    print "---main---"
	    time.sleep(1)

注意：p.start()函数后面的p.join()可以不加，这时父子进程同时运行。

如果加上p.join()，则父进程会一直阻塞等待子进程运行结束后才运行。子进程不结束，父进程一直等待不运行。

如果加上p.join(6)，则父进程最多会阻塞等待子进程运行6秒，6秒之后不管子进程是否结束，父进程都会继续往下运行。即使父进程先运行结束，父进程也不会退出，而是会等待子进程运行结束退出后，父进程才退出。如果子进程提前结束，则父进程提前继续往下运行。

总之：不管加不加p.join()函数，父进程都会等待子进程结束后才退出。加上p.join()函数只是起到让父进程阻塞等待，让子进程先运行的作用。