并发编程

1.开启子进程的两种方式:

# 方式1：
from multiprocessing import Process
import time

def task(name):
    print('%s is running'%(name))
    time.sleep(2)
    print('%s is done'%name)

if __name__ == '__main__':
    # p = Process(target=task,kwargs={'name':'子进程1'})
    p = Process(target=task,args=('子进程1',))
    p.start()  # 仅仅只是给os发了一个信号

    print('主')
'''
主
子进程1 is running
子进程1 is done
'''

# 方式二：
from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):  # 只能叫run
        print('%s is running'%(self.name))
        time.sleep(2)
        print('%s is done'%self.name)

if __name__ == '__main__':
    p = MyProcess('子进程1')
    p.start()

    print('主')

'''
主
子进程1 is running
子进程1 is done
'''

2.查看pid:

from multiprocessing import Process
import time
import os


def task(name):
    print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
    time.sleep(2)
    print('%s is done'%name,os.getpid(),'parent:',os.getppid())

if __name__ == '__main__':
    # p = Process(target=task,kwargs={'name':'子进程1'})
    p = Process(target=task,args=('子进程1',))
    p.start()  # 仅仅只是给os发了一个信号

    print('主',os.getpid(),'parent:',os.getppid())

'''
主 53400 parent: 12480  # pycharm的pid 
子进程1 is running 51432 parent: 53400
子进程1 is done 51432 parent: 53400
'''
'''
cmd: 
    tasklist | findstr pycharm
    pycharm64.exe                12480 Console                    1    776,848 K
'''
'''
linux:
    ps aux | grep pycharm
    bj        30819  0.0  0.0  21312   976 pts/1    R+   12:57   0:00 grep --color=auto pycharm
'''

'''
僵尸进程与孤儿进程： 
    如果父进程一直不死，子进程变成了僵尸进程后一直占着pid ,有害！
    父进程死之前，要wait()...回收僵尸进程的pid
    孤儿进程，父进程先死了，linux中最大的父进程init进程会回收孤儿进程的pid
        孤儿进程无害！最后init进程会回收！
        如果父进程不死，僵尸进程有害，一直占着pid
        
'''

3.Process对象的其他属性或方法：

# 1个子进程 join 方法：
from multiprocessing import Process
import time
import os


def task(name):
    print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
    time.sleep(2)
    print('%s is done'%name,os.getpid(),'parent:',os.getppid())

if __name__ == '__main__':
    p = Process(target=task,args=('子进程1',))
    p.start()  # 仅仅只是给os发了一个信号

    p.join()   # 主进程等待子进程的运行完成
    print('主',os.getpid(),'parent:',os.getppid())
    print(p.pid)  # 子进程结束了，但是变成了僵尸进程，子进程的pid 还存在
"""
子进程1 is running 43680 parent: 46512
子进程1 is done 43680 parent: 46512
主 46512 parent: 12480
43680
"""
"""
主进程结束了，基于它的子进程才会结束，即僵尸进程的pid才会被回收！
"""

# 多个子进程join方法 并行
from multiprocessing import Process
import time
import os

def task(name,n):
    print('%s is running'%(name))
    time.sleep(n)

if __name__ == '__main__':
    start = time.time()
    p1 = Process(target=task,args=('子进程1',5))
    p2 = Process(target=task,args=('子进程2',3))
    p3 = Process(target=task,args=('子进程3',2))
    p_l = [p1,p2,p3]
    # p1.start()  # 仅仅只是给os发了一个信号
    # p2.start()
    # p3.start()
    for p in p_l:
        p.start()

    # p1.join()  # 主进程在等... 等的是最长的那个时间 5 3 2
    # p2.join()  # 这里任然是并发
    # p3.join()
    for p in p_l:
        p.join()

    print('主',(time.time()-start))
'''
主 34504 parent: 12480
子进程1 is running 51732 parent: 34504
子进程3 is running 48864 parent: 34504
子进程2 is running 16240 parent: 34504
'''
'''
子进程3 is running 46212 parent: 35732
子进程1 is running 1528 parent: 35732
子进程2 is running 50244 parent: 35732
主 35732 parent: 12480
'''
"""
子进程1 is running
子进程2 is running
子进程3 is running
主 5.094129323959351  # 等的是5秒 任然是并发，不是串行。
"""

# 多个子进程join方法 串行
from multiprocessing import Process
import time
import os

def task(name,n):
    print('%s is running'%(name))
    time.sleep(n)

if __name__ == '__main__':
    start = time.time()
    p1 = Process(target=task,args=('子进程1',5))
    p2 = Process(target=task,args=('子进程2',3))
    p3 = Process(target=task,args=('子进程3',2))

    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

    print('主',(time.time()-start))  # 这个时候就是 串行
"""
子进程1 is running
子进程2 is running
子进程3 is running
主 10.235251665115356
"""

# 其他方法：is_alive() terminate() pid name
from multiprocessing import Process
import time
import os


def task(name):
    print('%s is running'%(name),os.getpid())
    time.sleep(2)

if __name__ == '__main__':
    # p = Process(target=task,args=('子进程1',))
    # p.start()
    # print(p.is_alive())
    # p.join()
    # print('主')
    # print(p.pid)   # 子进程即僵尸进程pid
    # print(p.is_alive())  # 查看进程是否还活着

    p = Process(target=task,name='sub-process',args=('子进程1',))
    p.start()
    # p.terminate()  # 给os 发了个信号，还没来的及杀死子进程
    # time.sleep(2)
    # print(p.is_alive()) # True --> 加了time.sleep(2) --> False
    print('主')

    print(p.name,p.pid)
"""
主
Process-1 48456
子进程1 is running 48456 
"""
"""
主
sub-process 43556
子进程1 is running 43556
"""

4.守护进程

"""
开进程的目的：并发任务；假设任务在主进程死后没意义存在了，就设为守护进程。
守护进程：
           0.p.daemon = True
           1.主进程结束时，守护进程就完了
           2.守护进程一定要在子进程start()前设置
           3.不允许在守护进程内在开子进程
"""
from multiprocessing import Process
import time

def task(name):
    print('%s is running'%name)
    time.sleep(2)
    # p = Process(target=time.sleep,args=(3,))
    # p.start()


if __name__ == "__main__":
    p = Process(target=task,args=('子进程1',))
    p.daemon = True  # 守护进程 主结束时，子进程就完了 ，守护进程一定要在子进程start() 前设置
    p.start()
    p.join()
    print('主')
"""
主
"""
"""
子进程1 is running
主
"""

"""练习题："""
# 思考下列代码的执行结果有可能有哪些情况？为什么？
from multiprocessing import Process
import time

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()
    print("main-------")  # 只要这里一运行，守护进程就完了

"""
main-------
456
end456
"""