网络编程——进程，多进程

一.进程的两种创建方法:
第一种:继承的方式,继承Process类
class MyProcess(Process):
　　def __init__(self,n,name):
　　　　super().__init__()
　　　　self.n = n
　　　　self.name = name
　　def run(self):

　　#在采用继承方式的时候，run函数必须要定义，因为Process中.start()之后就会自动执行run()  PS:一般都是在run方法下写执行自定义的代码块
　　　　# print(1+1)
　　　　# print(123)
　　　　print('子进程的进程ID',os.getpid())
　　　　print('你看看n>>',self.n)
if __name__ == '__main__':
　　p1 = MyProcess(100,name='子进程1')
　　p1.start() #给操作系统发送创建进程的指令,子进程创建好之后,要被执行,执行的时候就会执行run方法
　　print('p1.name',p1.name)
　　print('p1.pid',p1.pid)
　　print('主进程结束')
p1 = MyProcess(参数,name='名字') name是子进程的名字,可以自己命名
p1.pid() 打印出来的就是p1该子进程的pid值

 

第二种:普通的方法
import time
from multiprocessing import Process
import os

def func1(n):
　　time.sleep(1)
　　print(n)
def func2(n):
　　time.sleep(1)
　　print(n)
def func3(n):
　　time.sleep(1)
　　print(n)
def func4(n):
　　time.sleep(1)

　　print(n)

if __name__ == '__main__':
　　p1 = Process(target=func1,args=(1,))
　　p2 = Process(target=func2,args=(2,))
　　p3= Process(target=func3,args=(3,))
　　p4 = Process(target=func4,args=(4,))
　　p1.start() 开始一个子进程,底层调用的是p.run()
　　p2.start()
　　p3.start()
　　p4.start()
time.sleep(0.5)
print('主进程结束')

 

二.进程传参的两种参数

第一种:args

from multiprocessing import Process
def func (n):
    print(n)
if__name__ == '__main__':
    p = Process(target=func,args=(1,)) args传的是元组形式
    p.start()

第二种:kwargs

from multiprocessing import Process
def func (name):
    print(name)
if__name__ == '__main__':
    p = Process(target=func,kwargs={'name':' 吕三儿 '}) 关键字参数,key必须和func函数里的参数名字一样,否则报错
    p.start()
    print(' 主进程结束 ')

三.进程之间资源不共享(空间隔离的)

from multiprocessing import Process
global_num = 100
def func ():
    global global_num
    global_num = 0
    print(' 子进程 ', global_num)
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    time.sleep(1)
    print(' 主进程 ', global_num)

 

四.进程中异步变同步

from multiprocessing import Process
import time
def func ():
    time.sleep(2)
    print(" 子进程执行结束 ")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join() # 阻塞住 , 等待子进程 p 执行结束之后 , 主进程才能继续往下走
    print(' 主进程执行结束 ')

五.for循环在创建进程中的应用

第一种

from multiprocessing import Process
import time
def func (n):
    time.sleep(1)
    print(n)
if __name__ == '__main__':
    start = time.time()
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        p.join()
print(' 主进程结束 ')
print(time.time()-start)
            

第二种

from multiprocessing import Process 
import time
def func (n):
    # time.sleep(1)
    print(n)
if __name__ == '__main__':
    start = time.time()
    pro_list = []
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        pro_list.append(p)
    for p in pro_list:
        p.join()
print(' 主进程结束 ')
print(time.time()-start)
                

六.验证并发的执行时间

from multiprocessing import Process
import time
def func1 (n):
    time.sleep(n)
    print('func1', n)
def func2 (n):
    time.sleep(n)
    print('func2', n)
def func3 (n):
    start = time.time()
    time.sleep(n)
    print('func3', n)
    print(time.time() - start)
if __name__ == '__main__':
    p1 = Process(target=func1, args=(1,))
    p2 = Process(target=func2, args=(2,))
    p3 = Process(target=func3, args=(3,))
    p1.start()
    p2.start()
    p3.start()
print(' 主进程结束 ')

七.进程中的其他方法

from multiprocessing import Process
import time
def func ():
    print(" 子进程 ")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.terminate() # 给操作系统发了一个关闭 p1 子进程的信号 , 关闭进程
    time.sleep(1)
    print(p.is_alive()) # 判断子进程是否还活着
    print(' 主进程 ')

八.僵尸进程和孤儿进程

僵尸进程:子进程执行结束之后,操作系统把资源回收了,但是僵尸进程还是会遗留一些东西

from multiprocessing import Process
import time, os
def func ():
    time.sleep(2)
    print(os.getpid())
    print(' 僵尸进程 ')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join() # 子进程执行结束 , 操作系统将资源回收 , 但是子进程还是遗留了一些东西 , 叫做僵尸进程
    print(p.pid) # 让可以打印出来子进程的 id
    print(' 主进程结束 ')

孤儿进程:主进程结束了,但是子进程还在运行着(在主进程执行完毕之后,在任务管理器中将主进程结束,但
是子进程仍在继续执行,这时子进程就是孤儿进程)

from multiprocessing import Process
import time, os
def func ():
    time.sleep(30)
    print(' 孤儿进程 ', os.getpid())
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.pid)
    print(' 主进程 ', os.getpid())

九.守护进程

守护进程:守护进程跟随着父进程的代码执行结束而结束,守护进程不可以再创建子进程

from multiprocessing import Process
import time
def func ():
    print(' 子进程 ')
if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True 必须设置在p.start()之前
    p.start()
    time.sleep(1)
    print(' 主进程执行结束 ')