进程对象的属性或方法详解

子进程的出现是为了实现并发

from multiprocessing import Process
import time

x=100
def task():
    global x
    x=0
    print('done')  # 父进程在等待的时间内子进程执行完了，打印出“done”
if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    time.sleep(5) # 让父进程在原地等待，等了500s后，才执行下一行代码
    print(x)   # x输出还是100 证明两个进程是互相独立的

join（）让父进程在原地等，直到子进程运行结束才运行下面的程序。

# 1、join
from multiprocessing import Process
import time

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


if __name__ == '__main__':
    p=Process(target=task,args=('子进程1',))
    p.start()
    p.join() # 让父进程在原地等待，等到子进程运行完毕后，才执行下一行代码
    print('主')

p.join()--- 未用循环 同时发送进程创建请求，多进程同时运行。

from multiprocessing import Process
import time
def task(name,n):
    print('%s is running ' %name)
    time.sleep(n)
    print('%s is done ' % name)
if __name__ == '__main__':  # 开启多个进程，每个进程都向操作系统发出请求，操作系统分配内存
    p1=Process(target=task,args=('子进程1',1)) # 三个进程先创建出来
    p2=Process(target=task,args=('子进程2',2))
    p3=Process(target=task,args=('子进程3',3))
    start_time=time.time()
    p1.start()
    p2.start()
    p3.start()
    p3.join()   # 全部的子进程3s多一点执行完毕。多出来的一点是分配空间等的时间
    p1.join()  # 让父进程在原地等待，等到子进程执行完毕才执行下面的代码
    p2.join()   
    stop_time=time.time()
    print('主',(stop_time-start_time))

未同时向操作系统发起开启子进程的信号，所以都是在一个子进程结束才开始下一个信号发送，然后等待该子进程结束，进程没有同时运行，相当于串行，浪费时间。

from multiprocessing import Process
import time

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


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

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

    stop=time.time()
    print('主',(stop-start))

把创建好的进程放进列表里，每创建一个就向操作系统发起一个开启子进程的请求，循环列表里的子进程，让父进程进入等待状态。

from multiprocessing import Process
import time

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


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

    p_l=[]
    start=time.time()
    for i in range(1,4):
        p=Process(target=task,args=('子进程%s' %i,i))
        p_l.append(p)
        p.start()  # 把建好的进程放进列表里，同时建立一个进程向操作系统发起一个信号

    # print(p_l)
    for p in p_l:
        p.join()

    stop=time.time()

    print('主',(stop-start))

父进程内查看自己进程pid（processing id）

# pid
from multiprocessing import Process
import time
import os

def task(n):
    print('%s is running ' %os.getpid())
    time.sleep(n)
    print('%s is done ' % os.getpid())


if __name__ == '__main__':
    p1=Process(target=task,args=(10,))
    # print(p1.pid)
    p1.start()
    print(p1.pid) # 父进程内查看子pid的方式
    print('主')

查看自己和父进程的pid  ppid就是parent_pid 父进程

谁开启子进程谁就是他的父进程

from multiprocessing import Process
import time
import os

def task():
    print('自己的id：%s 父进程的id：%s ' %(os.getpid(),os.getppid())) # os.getppid()查看父进程id 8792
    time.sleep(200)

if __name__ == '__main__':
    p1=Process(target=task)
    p1.start()
    print('主',os.getpid(),os.getppid()) # 这里的getpid查看子进程pid 8792
    # 爹=》主--》儿子

了解知识点：子进程自定义名字

# 了解
# 具体的子进程名字
from multiprocessing import Process,current_process
import time

def task():
    print('子进程[%s]运行。。。。' %current_process().name)
    time.sleep(200)

if __name__ == '__main__':
    p1=Process(target=task,name='子进程1')
    p1.start()
    # print(p1.name)
    print('主')

terminate

from multiprocessing import Process,current_process
import time

def task():
    print('子进程[%s]运行。。。。' %current_process().name)
    time.sleep(2)

if __name__ == '__main__':
    p1=Process(target=task,name='子进程1')
    p1.start()

    # print(p1.is_alive())  # True
    # p1.join()
    # print(p1.is_alive())  # False

    p1.terminate()
    time.sleep(1)
    print(p1.is_alive())  # False  如果没有time.sleep(1) 就是True
    print('主')

tasklist | findstr 进程号  查找进程
taskkill /F/PID 进程号     杀死进程

僵尸进程和孤儿进程

僵尸进程与孤儿进程
在unix系统中init是所有进程的爹；创建进程用fork，回收进程用waitpid
僵尸进程（有害：占用pid）：子代先于父代终结，其部分信息（pid等）没有从系统中删除，需要父代回收。join中含有回收子代信息的功能。
孤儿进程（无害）：父代先于子代终结，子代终结后的部分信息由init代收。

from multiprocessing import Process                      
import time,os                                           
                                                         
def task(n):                                             
    print('%s is running' %n)                            
    time.sleep(n)                                        
                                                         
if __name__ == '__main__':                               
    p1=Process(target=task,args=(1,))                    
    p1.start()                                           
    p1.join()     # join中含有回收子代信息的功能（wait）                                       
    print('======主',os.getpid())                         
    time.sleep(10000)