多进程 fork process

fork（）

python中的os模块封装了常见的系统调用，其中fork可以轻松的创建子进程
注意：fork只能在unix，linux，mac上运行，windows不能运行

import os 
ret = os.fork()   #创建子进程，函数返回一个值，子进程中这个值一定为0，父进程得到的是子进程的pid号
if ret == 0:
    while True:
        print("----1----")
        time.sleep(1)
else:
    while True:
        print("----2---")
        time.sleep(1)

在Unix/Linux操作系统中，提供了⼀个fork()系统函数，它⾮常特殊。

普通的函数调⽤，调⽤⼀次，返回⼀次，但是fork()调⽤⼀次，返回两次，因
为操作系统⾃动把当前进程（称为⽗进程）复制了⼀份（称为⼦进程），然
后，分别在⽗进程和⼦进程内返回。

⼦进程永远返回0，⽽⽗进程返回⼦进程的ID。

这样做的理由是，⼀个⽗进程可以fork出很多⼦进程，所以，⽗进程要记下
每个⼦进程的ID，⽽⼦进程只需要调⽤getppid()就可以拿到⽗进程的ID。

import os
rpid = os.fork()
if rpid<0:
	print("fork调⽤失败。")
elif rpid == 0:
	print("我是⼦进程（%s），我的⽗进程是（%s）"%(os.getpid(),os.getppid()))
	x+=1
else:
	print("我是⽗进程（%s），我的⼦进程是（%s）"%(os.getpid(),rpid))
    print("⽗⼦进程都可以执⾏这⾥的代码")

多进程修改全局变量

import os
import time
num = 0
ret = os.fork()
if ret == 0:
 	 num += 1
	 print(num)
else:
	time.sleep(2)
	num += 2
	print(num)

运行结果：

多进程中，每个进程中所有数据（包括全局变量）都各有拥有⼀份，互
不影响

multiprocessing

如果你打算编写多进程的服务程序，Unix/Linux⽆疑是正确的选择。由于
Windows没有fork调⽤，难道在Windows上⽆法⽤Python编写多进程的程
序？

由于Python是跨平台的，⾃然也应该提供⼀个跨平台的多进程⽀持。
multiprocessing模块就是跨平台版本的多进程模块。

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

from multiprocessing import Process
import time
def test():
    while True:
        print("----test1----")
        time.sleep(1)
if __name__ == "__main__":    #  https://blog.csdn.net/anshuai_aw1/article/details/82344884
    p = Process(target=test)
    p.start()   #创建子进程
    while True:
        print("-------mian--------")
        time.sleep(1)

运行结果

说明
创建⼦进程时，只需要传⼊⼀个执⾏函数和函数的参数，创建⼀个
Process实例，⽤start()⽅法启动，这样创建进程⽐fork()还要简单。
join()⽅法可以等待⼦进程结束后再继续往下运⾏，通常⽤于进程间的同
步。

Process语法结构如下：

Process([group [, target [, name [, args [, kwargs]]]]])
target：表示这个进程实例所调⽤对象；
args：表示调⽤对象的位置参数元组；
kwargs：表示调⽤对象的关键字参数字典；
name：为当前进程实例的别名；
group：⼤多数情况下⽤不到；
Process类常⽤⽅法：
is_alive()：判断进程实例是否还在执⾏；
join([timeout])：是否等待进程实例执⾏结束，或等待多少秒；
start()：启动进程实例（创建⼦进程）；
run()：如果没有给定target参数，对这个对象调⽤start()⽅法时，就将执
⾏对象中的run()⽅法；
terminate()：不管任务是否完成，⽴即终⽌；
Process类常⽤属性：
name：当前进程实例别名，默认为Process-N，N为从1开始递增的整
数；
pid：当前进程实例的PID值；

进程的创建-Process⼦类

创建新的进程还能够使⽤类的⽅式，可以⾃定义⼀个类，继承Process类，每
次实例化这个类的时候，就等同于实例化⼀个进程对象，请看下⾯的实例：

from multiprocessing import Process
import time
import os
#继承Process类
class Process_Class(Process):
#因为Process类本身也有__init__⽅法，这个⼦类相当于重写了这个⽅法，
#但这样就会带来⼀个问题，我们并没有完全的初始化⼀个Process类，所以就不能使⽤从这个类继承的⼀些⽅法和属性，
#最好的⽅法就是将继承类本身传递给Process.__init__⽅法，完成这些初始化操作

	def __init__(self,interval):
		Process.__init__(self)
		self.interval = interval
#重写了Process类的run()⽅法
	def run(self):
	print("⼦进程(%s) 开始执⾏，⽗进程为（%s）"%(os.getpid(),os.getppid()))
	t_start = time.time()
	time.sleep(self.interval)
	t_stop = time.time()
	print("(%s)执⾏结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start))
if __name__=="__main__":
	t_start = time.time()
	print("当前程序进程(%s)"%os.getpid())
	p1 = Process_Class(2)
#对⼀个不包含target属性的Process类执⾏start()⽅法，就会运⾏这个类中的run()⽅法，所以这⾥会执⾏p1.run()
	p1.start()
	p1.join()
	t_stop = time.time()
	print("(%s)执⾏结束，耗时%0.2f"%(os.getpid(),t_stop-t_start))