创建多进程之multiprocess包中的process模块

创建多进程之multiprocess包中的process模块

Process([group [, target [, name [, args [, kwargs]]]]]) 由该类实例化得到的对象，表示一个子进程中任务

强调：

1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：

• group参数未使用，值始终为None
• target表示调用对象，即子进程要执行的任务
• args表示调用对象的位置参数元组，args=(1,2,‘cxk‘,)
• kwargs表示调用对象的字典，kwargs={‘name‘:‘cxk‘,‘age‘:98}
• name为子进程的名称

方法介绍

• p.start()：启动进程，并调用该子进程中的p.run()
• p.run()：进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
• p.terminate()：强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
• p.is_alive()：如果p仍然运行，返回True
• p.join([timeout])：主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

属性介绍

• p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
• p.name：进程的名称
• p.pid：进程的pid
• p.exitcode：进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
• p.authkey：进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

在Windows中使用process模块的注意事项

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__‘ 判断保护起来，import 的时候，就不会递归运行了。

import time
from multiprocessing import Process

def func(name):
    print('hello',name)
    time.sleep(2)
    print('我是子进程')

if __name__ == '__main__':
    p = Process(target=func,args=('usb',))
    p.start()    # 启动进程，并调用该子进程中的p.run()后开始运行,告诉操作系统我要开子进程，告诉完了这行代码就算执行完了，接着往下走，
                    # 具体操作系统什么时候开子，开多长时间跟你没关系。
    # time.sleep(3)
    print('执行主进程的内容')

方式一：

from multiprocessing import Process
import time

def task(x):
    print(f'子进程{x} start')
    time.sleep(2)
    print(f'子进程{x} end')

if __name__ == '__main__':
    p = Process(target=task,args=('cxk',))
    p2 = Process(target=task,args=('nike',))
    p.start()  # 告诉操作系统我要开子进程，告诉完了这行代码就算执行完了，接着往下走，具体操作系统什么时候开子，开多长时间跟你没关系。
    p2.start()
    time.sleep(4)
    print('我是父进程')

方式二：（不推荐）

from  multiprocessing import Process
import time

class Tset(Process):
    def __init__(self,gender):
        super().__init__()
        self.gender = gender

    def run(self):
        print(f'子进程是{self.gender} start')
        time.sleep(2)
        print('子进程 end')

if __name__ == '__main__':
    p = Tset('基佬')
    p.start()  # 向操作系统 发送开启子进程的请求
    # time.sleep(3)
    print('我是主进程')

from multiprocessing import Process
import time

x=0
def task():
    global x
    x= 100
    print('子进程的x修改为了{}'.format(x))

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    time.sleep(5)
    print(x)

p.join([timeout])：主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

方法一：

from multiprocessing import Process
import time

def foo():
    print('进程 start')
    time.sleep(3)
    print('进程 end')

if __name__ == '__main__':
    p = Process(target=foo)
    p.start()
    p.join()
    print('我是主进程')

方法二：

from  multiprocessing import Process
import time

def foo(x):
    print('进程 start')
    time.sleep(x)
    print('进程 end')

if __name__ == '__main__':
    p1 = Process(target=foo,args=(1,))
    p2 = Process(target=foo,args=(2,))
    p3 = Process(target=foo,args=(3,))
    start = time.time()
    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()
    end = time.time()  # 计算三个子进程的运行时间
    print(end-start)   # 3.83371901512146
    print('我是主进程')

方式3：

from multiprocessing import Process
import time

def foo(x):
    print(f'进程{x} start')
    time.sleep(x)
    print(f'进程{x} end')

if __name__ == '__main__':
    p1 = Process(target=foo,args=(1,))
    p2 = Process(target=foo,args=(2,))
    p3 = Process(target=foo,args=(3,))
    start = time.time()
    p1.start()
    p1.join()

    p2.start()
    p2.join()

    p3.start()
    p3.join()

    # 不如不开，直接穿行调用函数反而快
    # foo(1)
    # foo(2)
    # foo(3)

    end = time.time()
    print(end-start) # 7.275144100189209
    print('我是主进程')

方法四： （优化方法二的代码）

from  multiprocessing import Process
import time

def foo(x):
    print(f'进程{x} start')
    time.sleep(x)
    print(f'进程{x} end')

if __name__ == '__main__':
    start = time.time()
    p_list = []
    for i in range(1,4):
        p = Process(target=foo,args=(i,))
        p.start()
        p_list.append(p)
    print(p_list)
    for p in p_list:
        p.join()
    end = time.time()
    print(end-start)  # 3.721641778945923
    print('我是主进程')

from  multiprocessing import Process,current_process
import time,os

def func():

    print('子进程 start')
    print('在子进程中查看自己的Pid',current_process().pid)
    print('在子进程中查看父进程的pid',os.getpid())
    time.sleep(200)
    print('子进程 end')

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print('在主进程查看子进程的pid',p.pid) # 一定要写在 start() 之后
    print('主进程的pid:',os.getpid())
    print('主进程的父进程pid:',os.getppid())
    print('我是主进程')

** 记住这些就ok了 这个是要掌握的
站在当前进程的角度
os.getpid（） #获取当前进程的
pidos.getppid() # 获取当前进程的父进程的pid
子进程对象.pid #获取当前进程的子进程pid

from multiprocessing import Process,current_process
import time

def foo():
    print('进程 start')
    print('-----------',current_process().name)
    time.sleep(2)
    print('进程 end')

if __name__ == '__main__':
    p = Process(target=foo)
    p2 = Process(target=foo)
    p3 = Process(target=foo,name='cxk')  # 自定义进程

    p.start()
    p2.start()
    p3.start()
    print(p.is_alive())  # True
    time.sleep(5)
    print(p.is_alive())  # 代码运行完了就算该进程已经结束了（死了）False
    print(p.name)
    print(p2.name)
    print(p3.name)
    print('我是主函数')

p.terminate()：强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁

from  multiprocessing import Process
import time

def foo():
    print('进程 start')
    time.sleep(50)
    print('进程 end')

if __name__ == '__main__':
    p = Process(target=foo)

    p.start()
    p.terminate()  # 给操作系统发送了一个强行终止子进程的请求
    print(p.is_alive())   # True  系统还没处理到终止请求 ，所以为True
    p.join()
    print(p.is_alive())  # False
    print('我是主进程')

守护--》伴随

本质也是一个子进程

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

from multiprocessing import Process
import time

def foo():
    print('守护进程 start')
    time.sleep(5)
    print('守护进程 end')

if __name__ == '__main__':
    p = Process(target=foo)
    p.daemon = True  # 把这个子进程定义为守护进程
    p.start()
    time.sleep(2)
    print('我是主进程')

守护进程2：

from multiprocessing import Process
import time

def foo():
    print('守护进程 start')
    time.sleep(3)
    print('守护进程 end')

def func():
    print('子进程 start')
    time.sleep(5)
    print('子进程 end')

if __name__ == '__main__':
    p = Process(target=foo)
    p2 = Process(target=func)
    p.daemon = True  # 把这个子进程定义为守护进程
    p.start()
    p2.start()
    time.sleep(1)
    print('我是主进程')

from  multiprocessing import Process
import json,time,os

def search():
    time.sleep(1)  # 模拟网络io
    with open('db.txt',mode='rt',encoding='utf-8') as fr:
        res = json.load(fr)
        print(f'还剩{res["count"]}张票')

def get():
    with open('db.txt',mode='rt',encoding='utf-8') as fr:
        res = json.load(fr)
    time.sleep(1)  # 模拟网络io
    if res['count'] > 0:
        res['count'] -= 1
        with open('db.txt',mode='wt',encoding='utf-8') as fw:
            json.dump(res,fw)
            print(f'进程{os.getpid()} 抢票成功')
        time.sleep(1.5)  # 模拟网络io

    else:
        print('票已售罄！！！')

def task():
    search()
    get()

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=task)
        p.start()
        p.join()

# 为了保证数据的安全，要牺牲掉效率

原文地址：https://www.cnblogs.com/guapitomjoy/p/11515567.html