标签：def   守护   name   说明   系统   str   pid   join()   red   

进程的常用方法

一、常用方法

join():阻塞主进程，主进程会等待子进程结束后结束主进程

#单个进程
from multiprocessing import Process
import time

def Text():
    print('子进程开始')
    time.sleep(2)
    print('子进程结束')


if __name__ == '__main__':
    p = Process(target=Text)
    p.start()  #告诉操作系统子进程开始
    p.join()   #阻塞主进程，主进程会等待子进程结束后结束主进程
    print('主进程结束')

#多个进程
from multiprocessing import Process
import time

def Text(i):
    print(f'子进程{i}开始')
    time.sleep(1)
    print(f'子进程{i}结束')


if __name__ == '__main__':
    start = time.time()
    for i in range(1,5):
        p = Process(target=Text,args=(i,))
        p.start()  #告诉操作系统子进程开始
        p.join()  # 阻塞主进程，主进程会等待子进程结束后结束主进程
        end = time.time()
    print(end - start)
    print('主进程结束')

搞这个程序我们把它搞成了串行，一个运行完另一个才能开始，跑着一个程序我们花了6.954221963882446秒，所以他失去了真正的意义        
----------------------------------------------------------------------------------------
子进程1开始
子进程1结束
。。。
子进程4开始
子进程4结束
6.954221963882446
主进程结束

def Text(i):
    print(f'子进程{i}开始')
    time.sleep(1)
    print(f'子进程{i}结束')


if __name__ == '__main__':
    p_list = []  #建立一个空列表
    start = time.time()
    for i in range(1, 5):  #生成五个客户端
        p = Process(target=Text,args=(i,))
        p.start()  #子进程开始
        p_list.append(p)  # 将对象分别追加到这个空列表中
    for p in p_list:
        p.join()
    end = time.time()
    print(end-start)
    print('主进程结束')
 
这个才是真正的实现了并发，总共时间才用了2.6215157508850098秒，而且join()也发挥了真正的作用。
-----------------------------------------------------------------------------------------
子进程1开始
子进程2开始
子进程4开始
子进程3开始
子进程1结束
子进程2结束
子进程4结束
子进程3结束
2.6215157508850098
主进程结束

os.getpid():获取子进程的ID

os.getppid():获取子进程的父进程的ID

import os
from multiprocessing import Process,current_process
import time

def Text():
    print('子进程开始')
    print('子进程的pid:',os.getpid())
    print('子进程的pid:',current_process().pid)   #查看当前进程的pid
    time.sleep(15)
    print('子进程结束')


if __name__ == '__main__':
    p = Process(target=Text)
    p.start()  #告诉操作系统子进程开始
    time.sleep(1)
    print('父进程的pid:',current_process().pid) #查看当前进程的pid
    print('父进程的pid:',os.getpid()) #查看fu进程的pid
    print('父进程的父进程的pid:',os.getppid()) #父进程的父进程的pid  pycharm的pid
    print('主进程结束')

#current_process().pid 写在什么进程下就查看什么进程的pid
# os.getpid() 写在什么进程下就查看什么进程的pid

current_process().name：查看当前进程的名字

def Text(i):
    print('子进程开始')
    time.sleep(0.2)
    print('子进程结束')
    print(current_process().name)  #查看当前进程的进程名


if __name__ == '__main__':
    for i in range(1,3):
        p = Process(target=Text,args=(i,),name = str(i))    #name = i  进程的姓名可以更改,但姓名一定是字符串

        p.start()  #告诉操作系统子进程开始
        p.join()   #阻塞主进程，主进程会等待子进程结束后结束主进程
        time.sleep(1)
    print(current_process().name)  # 查看当前进程的进程名
    print('主进程结束')

.is_alive:查看进程是否还活着

def Text():
    print('子进程开始')
    time.sleep(0.1)
    print('子进程结束')


if __name__ == '__main__':
    p = Process(target=Text)
    p.start()  #告诉操作系统子进程开始
    print(p.is_alive())  # 查看当前进程是否还活着  #True
    time.sleep(3)
    print(p.is_alive())  #查看当前进程是否还活着   #False  代码运行完了就算死了
    print('主进程结束')

.terminate(): 直接终止子进程

def Text():
    print('子进程开始')
    time.sleep(20)
    print('子进程结束')


if __name__ == '__main__':
    p = Process(target=Text)
    p.start()  #告诉操作系统子进程开始
    time.sleep(3)  #让他睡三秒，让子进程先试一下，效果所需
    p.terminate()  #告诉操作系统直接终止子进程
    print(p.is_alive())  # 查看当前进程是否还活着  #True
    time.sleep(5)
    p.join()  #主进程等待子进程先结束
    print(p.is_alive())  #查看当前进程是否还活着   #False  代码运行完了就算死了
    print('主进程结束')
    
 以下是得到的结果，无论子进程运行到哪里，只要执行p.terminate()，就立刻结束子进程 
-------------------------------------------------------------------------
子进程开始
True
False
主进程结束

二、守护进程

守护进程可以比作是宫廷忠心耿耿的太监，只要皇帝死了，他就得陪葬，而皇帝就像是主进程。

守护进程的本质其实就是一个子进程

主进程的代码执行完毕守护进程直接结束。但是此时主进程可能没有结束

def Text():
    print('守护进程开始')
    time.sleep(1.5)
    print('守护进程结束')


if __name__ == '__main__':
    p = Process(target=Text)
    p.daemon = True   #将子进程设置为守护进程
    p.start()  #告诉操作系统子进程开始
    time.sleep(2)
    print('主进程结束')
  
并没有打印出'守护进程结束'就说明子进程还没有结束，但是子进程已经随着主进程的代码执行结束而结束了
---------------------------------------------------------------------------------
守护进程开始
主进程结束

#多个进程
from multiprocessing import Process
import time

def Text1():
    print('守护进程开始')
    time.sleep(2)
    print('守护进程结束')


def Text2():  #再定义一个子进程
    print('子进程开始')
    time.sleep(1.5)
    print('子进程结束')

if __name__ == '__main__':
    p1 = Process(target=Text1)
    p2 = Process(target=Text2)
    p1.daemon= True  #将Text设置为守护进程
    p1.start()  #告诉操作系统子进程开始
    p2.start()  #告诉操作系统子进程开始
    time.sleep(2)
    print('主进程结束')
    
以下并没有打印守护进程结束，就说明主进程代码执行完毕的时候，守护进程随即结束
---------------------------------------------------------------------------------
守护进程开始
子进程开始
主进程结束
子进程结束

进程的常用方法

标签：def   守护   name   说明   系统   str   pid   join()   red   

原文地址：https://www.cnblogs.com/yanjiayi098-001/p/11515355.html