创建进程
在python中提供了一个multiprocessing模块可以帮助我们使用多进程解决问题。在multiprocessing 模块中有一个类Process。
from multiprocessing import Process ''' group=None, 为日后开发新功能准备 target=None, 目标任务 name=None, 进程的姓名 args=(), 目标任务需要的位置参数 kwargs={}, 目标任务需要的字典参数 daemon=None):默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 ''' #方法介绍 p.start()#开启进程，使用run()方法 p.run()#进程启动时运行的方法是它去调用target指定的目标 p.terminate()#强制终止进程，不会进行清理操作 p.is_alive()#判断进程是否存活 p.join([timeout])#让在join方法之后的进程等待，直到p进程运行结束 强调:不同的操作系统创建进程的要求不一样 在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中 否则会直接报错 因为在无限制创建进程 在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
第一种方法
from multiprocessing import Process import time def test(): print('=======>') time.sleep(3) print('=======>') def test1(name): print(f'{name}') time.sleep(3) print('=======>') if __name__ == '__main__': p = Process(target=test) # p = Process(target=test1, args=('春游去动物园',)) p.start() print('主')
第二种方法
from multiprocessing import Process class Test(Process): def __init__(self,name): super().__init__() self.name = name def run(self): print(self.name) if __name__ == '__main__': p = Test('test') p.start() print('主') #自定义类主要是改写他的run()方法，run()方法在调用start()方法时一定会被调用
join
'''join让主进程等待子进程结束之后，再执行主进程。''' from multiprocessing import Process import time def task(name): print(f{name} is running) time.sleep(2) print(f{name} is gone) if __name__ == __main__: p = Process(target=task, args=(春游去动物园,)) # 创建一个进程对象 p.start() # p.join() print(111) print(主开始) 111 主开始 春游去动物园 is running 春游去动物园 is gone from multiprocessing import Process import time def task(name): print(f{name} is running) time.sleep(2) print(f{name} is gone) if __name__ == __main__: p = Process(target=task, args=(春游去动物园,)) # 创建一个进程对象 p.start() p.join() print(111) print(主开始) 春游去动物园 is running 春游去动物园 is gone 111 主开始
'''一般而言，主程序中如果单为一句print，则优先执行print语句（如果执行语句够多，则可见子进程执行）''' from multiprocessing import Process import time def task(name): print(f{name} is running) time.sleep(2) print(f{name} is gone) if __name__ == __main__: p = Process(target=task,args=(春游去动物园,)) # 创建一个进程对象 p.start() # p.join() print(111) time.sleep(0.5) print(主开始) 111 春游去动物园 is running 主开始 春游去动物园 is gone
'''如果程序中有连续多个join函数，则只有最先的join是起作用的''' from multiprocessing import Process import time def task(name,sec): print(f{name} is running) time.sleep(sec) print(f{name} is gone) if __name__ == __main__: start_time = time.time() p = Process(target=task,args=(常,3)) # 创建一个进程对象 p1 = Process(target=task,args=(辛,5)) # 创建一个进程对象 p2 = Process(target=task,args=(王,1)) # 创建一个进程对象 p.start() p1.start() p2.start() # join只针对主进程，如果join下面多次join他是不阻塞的 p.join() p1.join() p2.join() print(f主{time.time()-start_time}) 辛 is running 常 is running 王 is running 王 is gone 常 is gone 辛 is gone 主5.103694438934326 # 注：如果不是连续多个，比如这样： from multiprocessing import Process import time def task(name,sec): print(f{name} is running) time.sleep(sec) print(f{name} is gone) if __name__ == __main__: start_time = time.time() p = Process(target=task,args=(常,3)) # 创建一个进程对象 p1 = Process(target=task,args=(辛,5)) # 创建一个进程对象 p2 = Process(target=task,args=(王,1)) # 创建一个进程对象 p.start() p.join() p1.start() p1.join() p2.start() p2.join() print(f主{time.time()-start_time}) 常 is running 常 is gone 辛 is running 辛 is gone 王 is running 王 is gone 主9.267089128494263 # 这样就会先执行p进程，再执行p1进程，再执行p2进程
进程间数据默认隔离
from multiprocessing import Process a=100 def test(): global a a=50 print(a) # 50 if __name__ == '__main__': p = Process(target=test) p.start() print(a) # 100 100 50
进程对象属性和方法
查看进程号
'''第一种current_process函数''' from multiprocessing import Process,current_process a=100 def test(): global a a=50 print(a) # 50 if __name__ == '__main__': p = Process(target=test) p.start() print(current_process()) # 获取进程的名称 <_MainProcess name='MainProcess' parent=None started> print(current_process().pid) # 获取进程的id 8560 print(a) # 100 '''第二种os模块''' import os from multiprocessing import Process,current_process a=100 def test(): global a a=50 print(a) # 50 if __name__ == '__main__': p = Process(target=test) p.start() print(os.getpid()) # 9748 获取当前进程的进程号 print(os.getppid()) # 5220 获取当前进程的父进程号 print(a) # 100 os.getpid() # 获取当前进程的进程号 os.getppid() # 获取当前进程的父进程号
杀死子进程
terminate()：不管任务是否完成，立即终止子进程 from multiprocessing import Process,current_process import time a=100 def test(): global a time.sleep(3) a=50 print(a) if __name__ == '__main__': p = Process(target=test) p.start() p.terminate() print(a) 100
判断子进程是否存活
is_alive()：判断进程子进程是否还在活着 from multiprocessing import Process,current_process import time a=100 def test(): global a time.sleep(3) a=50 print(a) if __name__ == '__main__': p = Process(target=test) p.start() print(p.is_alive()) # True p.terminate() # 杀死进程 time.sleep(0.5) print(p.is_alive()) # False
僵尸进程与孤儿进程
僵尸进程
僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子 进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。 ''' 僵死进程：子进程退出后，会将该进程的重型资源释放掉（cpu，内存，打开的文件），子进程的进 程描述符仍然保存在系统中，比如pid。 ''' 所有的子进程在运行结束之后都会变成僵尸进程(死了没死透) 程序正常结束才会产生僵尸进程，如果强制关闭父进程，操作系统会把父进程已经运行结束的子进程全部 删除，也就不会产生僵尸进程了。 僵尸进程的危害: 系统的pid号是有限的，僵尸进程保留的信息如果一直不被释放，一直累计会导致没有可用的pid号而 导致系统不能产生新的进程
孤儿进程
孤儿进程(无害)：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿 进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。 ''' 子进程存活着 父进程意外死亡 子进程会被操作系统自动接管(儿童福利院) '''
守护进程
正常情况下,主进程默认等待子进程调用结束之后结束 守护进程在主进程执行代码结束后,自动终止 守护即死活全部参考守护的对象 对象死立刻死 主进程代码运行完毕,守护进程就会结束 from multiprocessing import Process import os, time def task(): print(进程%s开启 % os.getpid()) time.sleep(10) print(进程%s结束 % os.getpid()) if __name__ == '__main__': p = Process(target=task,daemon=True) # 在创建进程时也可以设置daemon，True为开启守护进程，默认为False。 #p.daemon = True # 这一行代码会把子进程变成守护代码，主进程运行完，子进程也就运行完了，不会打印进程结束的那行代码 p.start() print(主：%s % os.getpid()) time.sleep(3) 主：6812 进程10096开启
互斥锁
互斥锁的概念
互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。 注意: 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放 后，其它等待的线程再去抢这个锁。 互斥锁的意思就是互相排斥，我们可以把多个进程比喻多个人，互斥锁的工作原理就是多个人去争抢共同 的一个资源：如多个人要上同一个卫生间，一个人抢到卫生间后上一把锁，其他人都有外面等着，等到这个人 完成后解锁后，其他人又可以去争夺。所以互斥锁的原题，就是把某一功能并发改串行，虽然降低了效率，但 保证了数据安全不错乱。 锁相关知识 行锁:针对行数据加锁 同一时间只能一个人操作 表锁:针对表数据加锁 同一时间只能一个人操作 锁的应用范围很广 但是核心都是为了保证数据的安全!!!
互斥锁的使用
from multiprocessing import Process,Lock # 创建锁 mutex = Lock() # 上锁 mutex.acquire() ...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定... # 释放锁 mutex.release() 注意点: acquire和release方法之间的代码同一时刻只能有一个线程去操作 如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到 这个互斥锁释放后才能再次上锁。
互斥锁与join()的区别
互斥锁与join()的区别： 大前提：二者的原理都是一样，都是将并发变成串行，从而保证有序 区别一：join是按照人为指定的顺序执行，而互斥锁是所有进程平等地竞争，谁先抢到谁先执行。 区别二：互斥锁可以让一部分代码（修改共享数据的代码）串行，而join只能将代码整体串行。
抢票小案例
# db.json文件中的内容为{count: 100} from multiprocessing import Process, Lock import json, time import random def search(name): dic = json.load(open('db.json', 'r', encoding='utf-8')) time.sleep(random.randint(0, 2)) # 模拟网络延迟 print('%s查到剩余的票数为%s张' % (name, dic['count'])) def get(name): dic = json.load(open('db.json', 'r', encoding='utf-8')) time.sleep(0.3) # 模拟网络延迟 if dic['count'] > 0: time.sleep(0.1) # 模拟网络延迟 print('%s成功买到了剩下的第%s票' % (name, dic['count'])) dic['count'] -= 1 json.dump(dic, open('db.json', 'w', encoding='utf-8')) def rob_ticket(name, lock): search(name) with lock: # 相当于获得了lock.acquire()，执行代码体完，自动执行lock.release() get(name) if __name__ == '__main__': lock = Lock() for i in range(10): name = '路人%s' % i p = Process(target=rob_ticket, args=(name, lock)) p.start() 执行结果： 路人0查到剩余的票数为5张 路人1查到剩余的票数为5张 路人8查到剩余的票数为5张 路人7查到剩余的票数为5张 路人9查到剩余的票数为5张 路人0成功买到了剩下的第5票 路人1成功买到了剩下的第4票 路人2查到剩余的票数为5张 路人4查到剩余的票数为5张 路人3查到剩余的票数为5张 路人6查到剩余的票数为5张 路人8成功买到了剩下的第3票 路人7成功买到了剩下的第2票 路人5查到剩余的票数为5张 路人9成功买到了剩下的第1票