多进程操作

多进程操作

【一】multiprocessing模块介绍

• python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。

• • Python提供了multiprocessing。

  • multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。

• multiprocessing模块的功能众多：

• • 支持子进程、通信和共享数据、执行不同形式的同步

  • 提供了Process、Queue、Pipe、Lock等组件。

• 需要再次强调的一点是：

• • 与线程不同，进程没有任何共享状

  • 进程修改的数据，改动仅限于该进程内。

【1】创建进程的类

• 语法

Process([group [, target [, name [, args [, kwargs]]]]])

• 由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：

1. 需要使用关键字的方式来指定参数

2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

【2】参数介绍

• group参数未使用，值始终为None

• target表示调用对象，即子进程要执行的任务

• args表示调用对象的位置参数元组，args=(1,2,'ly',)

• kwargs表示调用对象的字典,kwargs={'name':'ly','age':18}

• name为子进程的名称

【3】方法介绍

• 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开启的进程

【4】属性介绍

• 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上启动子进程
# 必须将启动入口放到 if __name__ == '__main__':
​
'''
Since Windows has no fork, the multiprocessing module starts a new Python process **and** imports the calling module.
If Process() gets called upon import, then this sets off an infinite succession of new processes (**or** until your machine runs out of resources).
This **is** the reason **for** hiding calls to Process() inside
​
**if name == "main"**
since statements inside this **if**-statement will **not** get called upon import.
'''
​
'''
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 
这是隐藏对Process（）内部调用的原，使用if **name** == “**main** ”，
这个if语句中的语句将不会在导入时被调用。
'''

【1】multiprocessing使用

# 【1】导入模块
import multiprocessing
import random
import time
​
​
# 【2】创建进程程序
def work(name):
    print(f"{name} is starting \n")
    sleep_time = random.randint(1, 6)
    print(f"{name} is sleeping {sleep_time}")
    time.sleep(sleep_time)
    print(f"{name} is ending \n")
​
​
# 【3】制作多进程的启动入口
# （1）方式一：同过multiprocessing
def main_object():
    # (1)实例化得到子进程对象
    task_1 = multiprocessing.Process(
        # target 就是需要启动的子进程函数名
        target=work,
        # args 传入位置参数，位置参数必须带，元组类型
        args=('work_1',)
    )
    task_2 = multiprocessing.Process(
        target=work,
        kwargs={'name': 'work_2'}
    )
    # (2) 启动子进程
    task_1.start()
    task_2.start()
​
​
class MyProcess(multiprocessing.Process):
    def __init__(self, name):
        super().__init__()
        self.name = name
​
    def run(self):
        print(f"{self.name} is starting \n")
        sleep_time = random.randint(1, 6)
        print(f"{self.name} is sleeping {sleep_time} \n")
        time.sleep(sleep_time)
        print(f"{self.name} is ending \n")
​
​
def main_class():
    # 创建子进程一
    task_1 = MyProcess(name='work_1')
    task_2 = MyProcess(name='work_2')
​
    task_1.start()
    task_2.start()
​
​
# 【4】在主进程入口中启动当前子进程
if __name__ == '__main__':
    start_time = time.time()
    print(f"这是主进程 __main__ 开始：\n")
    main_class()
    print(f"这是主进程 __main__ 结束:\n")
    end_time = time.time()
    print(f'总耗时：{end_time - start_time}\n')
    
    # 这是主进程 __main__ 开始 :
    # 这是主进程 __main__ 结束 :
    # work_1 is starting
    # work_1 is sleeping 2 s
    # work_2 is starting
    # work_2 is sleeping 3 s
    # work_1 is ending
    # work_2 is ending
​
    # 执行流程
    # 先启动主进程
    # 分别启动子线程
    # 主进程结束
    # 等待子进程分别结束

【2】子进程之间的数据是隔离的

import multiprocessing
​
# 多进程：两个甚至多个进程
# 多进程中的子进程之间的数据不共享
money = 9999
​
​
def change_money(name):
    global money
    print(f"{name} 原始的money：{money}")
    # 在局部修改上面的money 局部修改不可变数据类型
    # 需要 提升变量等级 global
    money = 8888
    print(f'{name}')    # 当前子进程修改后的money
​
​
def main():
    for i in range(10):
        task = multiprocessing.Process(target=change_money,args=(i,))
        task.start()
​
​
if __name__ == '__main__':
    main()
    
0 原始的money：9999
0
1 原始的money：9999
1
2 原始的money：9999
2
3 原始的money：9999
3
4 原始的money：9999
4
5 原始的money：9999
5
6 原始的money：9999
6
7 原始的money：9999
7
8 原始的money：9999
8
9 原始的money：9999
9

【三】多进程实现服务端并发

import socket
​
client = socket.socket()
ip = '127.0.0.1'
port = 8802
addr = (ip, port)
client.connect(addr)
​
while True:
    letter = input("请输入字母:>>>> ").strip()
    client.send(letter.encode())
    if letter == 'q':
        client.close()
        break
    data = client.recv(1024)
    print(f"这是来自服务单的数据 :>>>> {data.decode()}")

【1】未实现并发

import socket
​
server = socket.socket()
​
ip = '127.0.0.1'
port = 8802
addr = (ip, port)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(addr)
​
server.listen(1)
conn, addr = server.accept()
while True:
    data = conn.recv(1024)
    if data.decode() == 'q':
        conn.close()
    print(f'这是来自客户端的数据 :>>>>{data.decode()}')
​
    conn.send(data.decode().upper().encode())

【2】实现并发

import multiprocessing
import socket
​
server = socket.socket()
ip = '127.0.0.1'
port = 8802
addr = (ip, port)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(addr)
server.listen(0)
​
​
def run(conn):
    while True:
        data = conn.recv(1024)
        if data.decode() == 'q':
            conn.close()
        print(f'这是来自客户端的数据 :>>>>{data.decode()}')
​
        conn.send(data.decode().upper().encode())
​
​
def main():
    while True:
        conn, addr = server.accept()
        task = multiprocessing.Process(target=run, args=(conn,))
        task.start()
​
​
if __name__ == '__main__':
    main()

【四】join实现并发

【1】主进程结束子进程未结束

# 【一】multiprocessing使用
# 【1】导入模块
import multiprocessing
import random
import time
​
​
# 【2】创建子进程程序
​
def work(name):
    print(f"{name} is starting \n")
    sleep_time = random.randint(1, 6)
    print(f"{name} is sleeping {sleep_time} s \n")
    time.sleep(sleep_time)
    print(f"{name} is ending \n")
​
​
# 【3】制作多进程的启动入口
# (1)方式一：同过multiprocessing的对象启动
def main_object():
    # 这个生成式在创建多个子进程
    task_list = [multiprocessing.Process(
        # target 就是需要启动的子进程的函数名
        target=work,
        # args 传入的位置参数，位置参数必须带 , 元组类型
        args=(f"work_{i}",)
    ) for i in range(5)]
    # （2）启动子进程
    task_list = [task.start() for task in task_list]
​
​
if __name__ == '__main__':
    start_time = time.time()
    print(f"这是主进程 __main__ 开始 :>>>> \n")
    main_object()
    print(f"这是主进程 __main__ 结束 :>>>> \n")
    end_time = time.time()
    print(f'总耗时 :>>>> {end_time - start_time}s')
​
    # 这是主进程 __main__ 开始 :>>>>
    # 这是主进程 __main__ 结束 :>>>>
    # work_1 is starting
    # work_1 is sleeping 5 s
    # work_2 is starting
    # work_2 is sleeping 4 s
    # work_4 is starting
    # work_4 is sleeping 4 s
    # work_0 is starting
    # work_0 is sleeping 2 s
    # work_3 is starting
    # work_3 is sleeping 2 s
    # work_0 is ending
    # work_3 is ending
    # work_2 is ending
    # work_4 is ending
    # work_1 is ending

【2】主进程等待子进程结束（join串行）

# 【一】multiprocessing使用
# 【1】导入模块
import multiprocessing
import random
import time


# 【2】创建子进程程序

def work(name):
    print(f"{name} is starting \n")
    sleep_time = random.randint(1, 6)
    print(f"{name} is sleeping {sleep_time} s \n")
    time.sleep(sleep_time)
    print(f"{name} is ending \n")


# 【3】制作多进程的启动入口
# (1)方式一：同过multiprocessing的对象启动
def main_object():
    # 这个生成式在创建多个子进程
    task_list = [multiprocessing.Process(
        # target 就是需要启动的子进程的函数名
        target=work,
        # args 传入的位置参数，位置参数必须带 , 元组类型
        args=(f"work_{i}",)
    ) for i in range(5)]
    # （2）启动子进程
    for task in task_list:
        task.start()
        task.join()


if __name__ == '__main__':
    start_time = time.time()
    print(f"这是主进程 __main__ 开始 :>>>> \n")
    main_object()
    print(f"这是主进程 __main__ 结束 :>>>> \n")
    end_time = time.time()
    print(f'总耗时 :>>>> {end_time - start_time}s')

    
这是主进程 __main__ 开始 :>>>> 

work_0 is starting 

work_0 is sleeping 4 s 

work_0 is ending 

work_1 is starting 

work_1 is sleeping 3 s 

work_1 is ending 

work_2 is starting 

work_2 is sleeping 3 s 

work_2 is ending 

work_3 is starting 

work_3 is sleeping 6 s 

work_3 is ending 

work_4 is starting 

work_4 is sleeping 4 s 

work_4 is ending 

这是主进程 __main__ 结束 :>>>> 

总耗时 :>>>> 20.522260427474976s

【3】主进程等待子进程结束（join并行）

# 【一】multiprocessing使用
# 【1】导入模块
import multiprocessing
import random
import time
​
​
# 【2】创建子进程程序
​
def work(name):
    print(f"{name} is starting \n")
    sleep_time = random.randint(1, 6)
    print(f"{name} is sleeping {sleep_time} s \n")
    time.sleep(sleep_time)
    print(f"{name} is ending \n")
​
​
# 【3】制作多进程的启动入口
# (1)方式一：同过multiprocessing的对象启动
def main_object():
    task_list = []
    # 这个生成式在创建多个子进程
    for i in range(5):
        task = multiprocessing.Process(
            # target 就是需要启动的子进程的函数名
            target=work,
            # args 传入的位置参数，位置参数必须带 , 元组类型
            args=(f"work_{i}",)
        )
        task.start()
        task_list.append(task)
    # （2）启动子进程
    for task in task_list:
        task.join()
​
​
if __name__ == '__main__':
    start_time = time.time()
    print(f"这是主进程 __main__ 开始 :>>>> \n")
    main_object()
    print(f"这是主进程 __main__ 结束 :>>>> \n")
    end_time = time.time()
    print(f'总耗时 :>>>> {end_time - start_time}s')
    
    
这是主进程 __main__ 开始 :>>>> 
​
work_0 is starting 
​
work_0 is sleeping 6 s 
​
work_1 is starting 
​
work_1 is sleeping 2 s 
​
work_2 is starting 
​
work_2 is sleeping 5 s 
​
work_3 is starting 
​
work_3 is sleeping 1 s 
​
work_4 is starting 
​
work_4 is sleeping 2 s 
​
work_3 is ending 
​
work_1 is ending 
​
work_4 is ending 
​
work_2 is ending 
​
work_0 is ending 
​
这是主进程 __main__ 结束 :>>>> 
​
总耗时 :>>>> 6.146602630615234s
​