【补充】进程理论：开设多进程的方式、多进程实现服务端并发、join实现并发

【补充】进程理论

【一】开设多进程的两种方式

【1】在Windows上启动子进程

#必须将启动入口放到 if __name__ == '__main__':
'''
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 
这是隐藏对Process（）内部调用的原，使用if **name** == “**main** ”，
这个if语句中的语句将不会在导入时被调用。
'''

【2】multiprocessing使用

# 【二】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():
    # （1）实例化得到子进程对象
    task_1 = multiprocessing.Process(
        # target 就是需要启动的子进程的函数名
        target=work,
        # args 传入的位置参数，位置参数必须带 , 元组类型
        args=("work_1",)
    )
    task_2 = multiprocessing.Process(
        target=work,
        kwargs={'name': 'work_2'}
    )
    # （2）启动子进程
    # p.start()
    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} s \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_object()
    main_class()
    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 2 s
    # work_2 is starting
    # work_2 is sleeping 3 s
    # work_1 is ending
    # work_2 is ending

    # 执行流程
    # 先启动主进程
    # 分别启动子线程
    # 主进程结束
    # 等待子进程分别结束

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

import multiprocessing

# 多进程：两个甚至多个进程
# 多进程中的子进程之间的数据不共享
money = 9999


def change_money(name):
    global money
    print(f'{name} 原始的money :>>>> {money}')
    # 在局部修改上面的 money 局部修改不可变数据类型
    # 需要 提升变量等级 global
    money = 8888
    print(f'{name} 当前子进程修改后的money :>>>> {money}')


def main():
    for i in range(10):
        task = multiprocessing.Process(
            target=change_money,
            args=(i,)
        )
        task.start()


if __name__ == '__main__':
    main()

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

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__ 开始 :>>>>
    # 这是主进程 __main__ 结束 :>>>>
    # 并行变串行 ； 所有主进程等待所有子进程结束后才会结束
    # 依次执行每一个子进程
    # 并且是拿到上一个子进程的结果后才会执行下一个子进程
    # 总耗时 :>>>> 22.509196758270264s

【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__ 开始 :>>>>
    # 这是主进程 __main__ 结束 :>>>>
    # 总耗时 :>>>> 5.176285266876221s
    # 并行
    # 并且主进程等待所有子进程结束后再结束
    # 耗时是最长的子进程的耗时