day 38 进程 与 子进程 （开启进程 + 进程中的数据隔离 + 守护进程 + 进程中的其他方法 ）

进程：

　　

import os
import time
print(os.getpid())  # 进程id
time.sleep(1000)
print(os.getpid())
# 4核 —— 4个进程
# 一个进程 —— cpu
# 多进程 —— 4个进程


创建进程num1：

　　

import os
import time
from multiprocessing import Process

def process1():
    print('process1 : ',os.getpid())
    time.sleep(10)

if __name__ == '__main__':
    print(os.getpid())
    p = Process(target=process1)
    p.start()


创建进程2：
　　

import os
import time
from multiprocessing import Process

def process1(n,name,num = 20):
    print('process1 : ',os.getpid())
    print('n : ',n,name,num)
    time.sleep(10)

if __name__ == '__main__':
    print(os.getpid())
    p = Process(target=process1,args=[1,'alex',30])
    p.start()




进程与子进程：

　　

# 主进程
# 子进程
# 父进程
import os
import time
from multiprocessing import Process

def func():
    print(os.getpid(),os.getppid())
    time.sleep(1)

if __name__ == '__main__':
    print(os.getpid(),os.getppid())  # process id,parent process id
    Process(target=func).start()    # func
    print('*'*20)
    time.sleep(0.5)
    print('*'*40)
    # p = Process(target=func)
    # p.start()

# 主进程默认会等待子进程执行完毕之后才结束
# 主进程和子进程之间的代码是异步的
# 为什么主进程要等待子进程结束 回收一些子进程的资源
# 开启一个进程是有时间开销的 ：操作系统响应开启进程指令，给这个进程分配必要的资源

同步控制：

　　

import os
from multiprocessing import Process

def func(exp):
    print(os.getpid(),os.getppid())
    result = eval(exp)
    with open('file','w') as f:
        f.write(str(result))

if __name__ == '__main__':
    print(os.getpid(),os.getppid())  # process id,parent process id
    # 3*5+5/6
    p = Process(target=func,args=['3*5'])    # func
    p.start()
    ret = 5/6
    p.join()  # join方法能够检测到p进程是否已经执行完了，阻塞知道p执行结束
    with open('file') as f:
        result = f.read()
    ret = ret + int(result)
    print(ret)

开启多个进程：

　　

import os
import time
from multiprocessing import Process

def process(n):
    print(os.getpid(),os.getppid())
    time.sleep(1)
    print(n)
if __name__ == '__main__':
    p_lst = []
    for i in range(10):
        p = Process(target=process,args=[i,])
        p.start()
        p_lst.append(p)
    for p in p_lst:p.join()   # 检测p是否结束 如果没有结束就阻塞直到结束 如果已经结束了就不阻塞
    print('求和')




开启进程的第二种方式：
　　

import os
from multiprocessing import Process
class Myprocess(Process):
    def __init__(self,*args):
        super().__init__()
        self.args = args
    def run(self):
        print(os.getpid(),self.name,self.pid)
        for name in self.args:
            print('%s和女主播聊天'%name)

if __name__ == '__main__':
    print(os.getpid())
    p = Myprocess('yuan','wusir')
    p.start()   # 在执行start的时候，会帮我们主动执行run方法中的内容

进程中的数据隔离：
　　

from multiprocessing import Process
n = 100
def func():
    global n
    n += 1
    print('son : ',n)


if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()
    print(n)

守护进程：

import time
from multiprocessing import Process

def func():
    print('son start')
    while True:
        time.sleep(1)
        print('son')

def func2():
    print('start :in func2')
    time.sleep(5)
    print('end : in func2')
if __name__ == '__main__':
    p = Process(target=func)
    # 在一个进程开启之前可以设置它为一个守护进程
    p.daemon = True
    p.start()
    Process(target=func2).start()
    time.sleep(2)
    print('在主进程中')



# 分析：
    # 主进程的代码 大概在2s多的时候就结束了
    # p2子进程实在5s多的时候结束
    # 主进程结束
    # p是在什么时候结束的？
        # p是在主进程的代码执行完毕之后就结束了



    # 主进程会等待子进程的结束而结束
    # 守护进程的意义：
        # 子进程会随着主进程代码的执行结束而结束
        # 注意：守护进程不会关系主进程什么时候结束，我只关心主进程中的代码什么时候结束
    # 守护进程的作用：
        # 守护主进程，程序报活
        # 主进程开启的时候 建立一个守护进程
        # 守护进程只负责每隔1分钟 就给检测程序发一条消息

进程中的其他方法：

# import time
# from multiprocessing import Process
#
# def func():
#     print('wahaha')
#     time.sleep(20)
#     print('wahaha end')
# if __name__ == '__main__':
#     p = Process(target=func)
#     p.start()
#     print(p.is_alive())
#     time.sleep(1)
#     p.terminate()    # 在主进程中结束一个子进程
#     print(p.is_alive())
#     time.sleep(0.5)
#     print(p.is_alive())
#     # print(p.pid)
#     # print(p.name)

import time
from multiprocessing import Process

def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    p1=Process(target=foo)
    p2=Process(target=bar)

    p1.daemon=True
    p1.start()
    p2.start()
    time.sleep(0.1)
    print("main-------")