多个子进程的开启

from multiprocessing import Process
import time
import random

def func(i):
    print(‘我是%s‘%i)


if __name__ == ‘__main__‘:
    l = []
    addr = [‘河南的‘,‘山东的‘,‘辽宁的‘,‘湖南的‘]
    for i in addr:
        p = Process(target=func,args=(i,))
        p.start()
        l.append(p)
    [p.join() for p in l]
    # time.sleep(1)
    print(‘我选%s‘%(random.choice(addr)))

from multiprocessing import Process
import time
import os
###########################################开启子进程的一种方式
def func(i):
    time.sleep(1)
    print(‘这里是儿子进程,儿子自己的pid是%s,儿子的父进程的pid是%s‘%(os.getpid(),os.getppid()))

# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid
if __name__ == ‘__main__‘:
    p = Process(target=func,args=(1,))# 实例化一个进程对象
    p.start()# 开启一个子进程
    print(‘这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s‘%(os.getpid(),os.getppid()))

######################################## 开启子进程的另外一种方式，以继承的方式

class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()
    def run(self):
        print(‘这是以继承类的方式开启的子进程‘)

if __name__ == ‘__main__‘:
    p1 = MyProcess()
    p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程，   就绪状态
    # p1.run()# 告诉操作系统，现在马上帮我执行这个子进程           执行


class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()#  执行父类的__init__方法
        # self.name = name

    def run(self):
        print(‘这是以继承类的方式开启的子进程,他的名字是%s‘%self.name)

if __name__ == ‘__main__‘:
    p1 = MyProcess()
    p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程，   就绪状态
    p1.run()# 告诉操作系统，现在马上帮我执行这个子进程           执行





################################################如何开启多个不同的子进程

def func(i):
    time.sleep(1)
    print(‘这里是儿子%s进程,儿子自己的pid是%s,儿子的父进程的pid是%s‘%(i,os.getpid(),os.getppid()))

# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid
if __name__ == ‘__main__‘:
    for i in range(2):
        p = Process(target=func,args=(i,))# 实例化一个进程对象
        p.start()# 开启一个子进程
    print(‘这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s‘%(os.getpid(),os.getppid()))

from multiprocessing import Process
import time

def func():
    time.sleep(100)
    print(‘这里是儿子哦‘)

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(1)
    print(‘这是爸爸‘)
总结一下：
    守护进程：跟随着父进程的代码执行结束，守护进程就结束

###########################################守护进程的特点

from multiprocessing import Process
import time

def func1():
    print(‘这里是孙子‘)

def func():
    p = Process(target=func1)
    p.start()
    time.sleep(5)
    print(‘这里是儿子哦‘)

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(1)
    print(‘这是爸爸‘)
    守护进程：不允许开启子进程

#######################################  守护进程的用法
from multiprocessing import Process
import time


def func():
    for i in range(10):
        time.sleep(1)
        print(time.strftime(‘%H:%M:%S‘))

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(5)
    print(‘这是爸爸‘)

from multiprocessing import Process
import time

def func():
    for i in range(500):
        time.sleep(0.01)
        print(‘儿子在这里‘)

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.start()
    p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
    # time.sleep(1)
    for i in range(100):
        time.sleep(0.01)
        print(‘爸爸在这里‘)

# 开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束
# p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
# 如何把父进程和子进程之间的关系变为同步或者异步？
# 父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
# join必须放在start()后边