方式一：os.fork()
子进程是从os.fork得到的值，然后赋值开始执行的。即子进程不执行os.fork，从得到的值开始执行。
父进程中fork之前的内容子进程同样会复制，但父子进程空间独立，fork之后的修改不会影响到对方。
父子进程在执行上互不影响，谁先执行，谁先执行完不确定。
父子进程之间相互独立，全局变量，局部变量都互不影响。
父进程执行完就结束，子进程会继续执行。主进程不会因为子进程没结束而等待。
子进程虽然复制父进程的空间，但是有自己的特性，比如自己的PID，进程PCB，进程栈空间等。
单个fork
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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()
子进程执行的函数结束，子进程就结束了。父进程等待
python基础教程子进程结束后才退出。
子进程修改全局变量或者局部变量，对父进程没有丝毫影响。
父进程执行完不退出，子进程会继续执行。父进程等待子进程结束后才退出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# --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类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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()函数只是起到让父进程阻塞等待，让子进程先运行的作用。
