day35-子进程的开启

#1、异步非阻塞：
import os
from multiprocessing import Process
def func():
    print('子进程:',os.getpid())

if __name__ == '__main__':
    p = Process(target = func)    #创建一个进程对象。
    print('主进程:',os.getpid())
    p.start()                    #开启子进程，至于系统什么时候调度，不管它，先执行下面的代码，属于异步。
    print('主进程:',os.getpid())
# 主进程: 14112
# 主进程: 14112
# 子进程：12860

#2、同步非阻塞：
import os
from multiprocessing import Process
def func():
    print('子进程：',os.getpid())

if __name__ == '__main__':    #下面没有创建进程对象，只有一个进程，属于同步。
    print('去银行取钱')
    func()
    print('取完钱了')
# 去银行取钱
# 子进程： 5668
# 取完钱了

#3、异步阻塞：
import os
import time
from multiprocessing import Process:
def func():
    print('子进程:',os.getpid())

if __name__ == '__main__':
    p = Process(target = func)
    print('主进程:',os.getpid())
    p.start()                   #开启子进程
    time.sleep(10)               #主进程阻塞10秒，跟子进程没关系，不影响子进程，属于异步阻塞。

#4、同步阻塞：
import os
import time
from multiprocessing import Process
def func():
    print('子进程：',os.getpid())

if __name__ == '__main__':
    print('去银行取钱')
    func()
    time.sleep(10)         #只有一个进程，阻塞10秒，属于同步阻塞。
    print('取完钱了')

#5、父进程创建子进程：主进程和父进程的pid是一样的，说明它们是同一进程。主进程创建了子进程，也就是父进程创建了子进程。
import os
from multiprocessing import Process
def func():
    print('子进程:',os.getpid())
    print('父进程:',os.getppid())

if __name__ == '__main__':
    p = Process(target = func)
    p.start()
    print('主进程:',os.getpid())
# 主进程: 16284
# 子进程: 10972
# 父进程: 16284

#6、主进程控制子进程，主进程传参给子进程：
import os
from multiprocessing import Process
def func(money):
    print('取%d元'%money)

if __name__ == '__main__':
    p = Process(target = func,args = (8000000,)) #args是元祖
    p.start()
#取8000000元

#7、子进程优先执行，主进程阻塞：
import os
from multiprocessing import Process
def func():
    print('子进程',os.getpid())

if __name__ == '__main__':
    p = Process(target = func)
    p.start()
    p.join()                   #主进程等待子进程结束之后才结束，子进程执行，主进程阻塞在p.join()的位置
    print('主进程',os.getpid())
#子进程 23080
#主进程 10912

#8、要求子进程重复三次，主进程最后才执行：
import os
from multiprocessing import Process
def func():
    print("子进程",os.getpid())

if __name__ == '__main__':
    p = Process(target = func)
    p1 = Process(target = func)
    p2 = Process(target = func)
    p.start()
    p1.start()
    p2.start()
    p.join()
    p1.join()
    p2.join()
    print('主进程',os.getpid())
# 子进程 7436
# 子进程 19988
# 子进程 17712
# 主进程 1464

#9、如果子进程重复很多次，上面代码就很麻烦,要使用for循环解决：
import os
from multiprocessing import Process
def func():
    print("子进程",os.getpid())

if __name__ == '__main__':
    p_list = []
    for i in range(10):
        p = Process(target = func)
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('主进程',os.getpid())

#10、多个子进程开始，是无法知道哪个先执行，没有顺序的。但是在p.start()后面加上p.join()可以让当前子进程优先执行，这样就有顺序了。
import os
from multiprocessing import Process
def func(i):
    print('序号%d 子进程的pid是%d'%(i,os.getpid()))

if __name__ == '__main__':
    for i in range(3):
        p = Process(target = func,args=(i,))
        p.start()
    print('主进程',os.getpid())
# 主进程 1976
# 序号0 子进程的pid是17912
# 序号2 子进程的pid是15904
# 序号1 子进程的pid是17612

#11、多进程的特点：数据隔离。子进程之间的数据是隔离的，不共享，他们没有关系，互不影响。
# 在windows下，每创建一个子进程，都会创建一个空间对当前模块(day35-子进程的开启.py)的代码执行一遍，
# 所以每创建一个子进程，n都是等于100。
from multiprocessing import Process
n = 100
def func(i):
    global n
    n = n - 1
    print(i,n)

if __name__ == '__main__':
    for i in range(3):
        p = Process(target=func,args=(i,))
        p.start()
# 0 99
# 2 99
# 1 99

#12、使用子类继承父类的方式来开启子进程，并且传参：必须继承Process类和定义run方法。
import os
from multiprocessing import Process
class MyProcess(Process):                #必须继承Process类。
    def __init__(self,args1,args2,args3):
        super().__init__()            #子类继承父类__init__方法里面的属性。
        self.args1 = args1
        self.args2 = args2
        self.args3 = args3

    def run(self):                        #必须定义一个run方法。
        print('子进程:',os.getpid(),self.args1,self.args2,self.args3)
        self.walk()            #调用walk方法，walk方法在子进程当中执行。

    def walk(self):
        print('子进程walk方法',os.getpid())

if __name__ == '__main__':
    p = MyProcess(1,2,3)
    p.start()              #默认调用run方法。
    p.walk()                    #在主进程当中执行。
    print('主进程',os.getpid())
# 子进程walk方法 756 #pid跟主进程的一样，证明在主进程当中执行。
# 主进程 756
# 子进程: 15124 1 2 3
# 子进程walk方法 15124 #pid一样，证明walk方法在子进程当中执行。