26.并发编制【二】多进程

【一】多进程理论

1）概念

  • 程序：仅仅只是一堆代码和数据
  • 进程：正在运行的一个程序或任务
  • 单进程：一个时间段只做一件事
  • 多进程：一个时间段做多个任务

2）进程的调度问题

1.先来先服务算法

  • 依次执行

优点：任务依次进行

缺点：一个结束才进行下一个

2.短作业优先调度算法

  • 先执行时间短的

有利于短作业，但对长作业不利

3.时间片轮转法

  • 让每个进程在就绪队列等待与享受服务的时间成比例
  • 即合理分配时间和空间资源

4.多级反馈队列

  • 为多个就绪队列设置优先级
  • 新进程等待调用
  • 按顺序调度队列

4）并发与并行

1.串行

  • 每个程序依次进行

2.并发

  • 是伪并行，即看起来是同时运行

3.并行

  • 同时运行

4.多道技术

  • 内存中同时存入多道（多个）程序
  • cpu从一个进程快速切换到另外一个
  • 使每个进程各自运行几十或几百毫秒
  • 这样，虽然在某一个瞬间一个cpu只能执行一个任务
  • 但在1秒内，cpu却可以运行多个进程
  • 这就给人产生了并行的错觉，即伪并发
  • 以此来区分多处理器操作系统的真正硬件并行（多个cpu共享同一个物理内存）

5）同步/异步/阻塞/非阻塞

1.同步

  • 当一个程序执行后，必须等待当前程序执行完成才能继续下一个任务

2.异步

  • 当一个程序运行后，无需等待结果出来便可以继续下一个任务

3.阻塞

  • 调用结果返回之前，当前程序会一种被挂起

4.非阻塞

  • 调用结果返回之前，当前程序不会一种被挂起

5.小结

1）同步/异步

  • 同步与异步针对的是函数/任务的调用方式

  • 同步就是当一个进程发起一个函数（任务）调用的时候

    • 一直等到函数（任务）完成，而进程继续处于激活状态。

  • 而异步情况下是当一个进程发起一个函数（任务）调用的时候

    • 不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。
（2）阻塞/非阻塞
  • 阻塞与非阻塞针对的是进程或线程
  • 阻塞是当请求不能满足的时候就将进程挂起
  • 而非阻塞则不会阻塞当前进程

6）进程的创建

1.通过系统创建新进程

1》系统初始化
  • Windows中的任务管理器
  • 随着开机，自动被启动
2》进程中开启子进程
  • 从主进程打开的子进程
3》交互式请求
  • 双击打开的程序
4》批处理作业的初始化
  • 只会在大型的工厂中

2.不同系统的新进程的创建方式

无论哪一种，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的

1》Windows
  • CreateProcess，既处理进程的创建，也负责把正确的程序装入新进程。
2》UNIX
  • fork，fork会创建一个与父进程一模一样的副本

3.不同系统创建的子进程的异同

1》相同点
  • 进程创建后，父进程和子进程有各自不同的地址空间（多道技术要求物理层面实现进程之间内存的隔离）
  • 任何一个进程的在其地址空间中的修改都不会影响到另外一个进程。
2》不同点
  • 在UNIX中，子进程的初始地址空间是父进程的一个副本

7）进程的终止

正常退出(自愿)

出错退出(自愿)

严重错误(非自愿)

被其他进程杀死(非自愿)

8）进程的状态

  • 进程状态反映进程执行过程的变化。
  • 这些状态随着进程的执行和外界条件的变化而转换。

1.三态模型

运行态 ： 已经在使用过程中的状态

就绪态 ： 双击应用程序启动的过程中

阻塞态 ： 上传文件需要读取文件数据的过程

2.五态模型

创建 ： 双击应用程序启动的过程中

就绪 ： 应用程序已经准备好了

执行 ： 应用程序正在执行

阻塞 ： 应用处于等待状态

终止 ： 应用程序结束

【二】multiprocessing模块

1）介绍

概念

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

功能

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

注意

  • 与线程不同，进程没有任何共享状，进程修改的数据，改动仅限于该进程内。

【三】Process类的介绍

import multiprocessing

p = multiprocessing.Process(group=None,  
                            # 参数表示一个组，值始终为None
                            target=None,  
                            # 表示调用的对象 要让子进程完成的任务
                            name=None,  
                            # 子进程的名称
                            args=(),  
                            # 元组类型，子进程完成的任务的函数的参数
                            kwargs={}
                           # 调用对象的字典
                           )  

p.start()：  
# 启动进程，并调用该子进程中的p.run()
p.run():
# 进程运行时的方法,真正的调用自己传入的进程方法
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字符的字符串。
# 这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功

【四】Process类的使用

  • 注意：在windows中Process()必须放到 if __name__ == '__main__':下

1）创建并开启子进程的两种方式

1.直接使用Process方法

import multiprocessing
import random
import time
# 创建子进程程序
def work(name):
    sleep_time = random.randint(1, 6)
    print(f'{name}将舒眠{sleep_time}秒')
    time.sleep(sleep_time)
    print(f'{name}醒来')
if __name__ == '__main__':
    st1 = multiprocessing.Process(target=work,args=('ST1',))
    st2 = multiprocessing.Process(target=work,args=('ST2',))
    st1.start()
    st2.start()
# ST1将舒眠5秒
# ST2将舒眠3秒
# ST2醒来
# ST1醒来

2.继承Process方法

import multiprocessing
import random
import time
class MyProcess(multiprocessing.Process):
    def __init__(self, name):
        super().__init__()
        self.name = name
    # 创建子进程程序
    def run(self):
        sleep_time = random.randint(1, 6)
        print(f'{self.name}将舒眠{sleep_time}秒')
        time.sleep(sleep_time)
        print(f'{self.name}醒来')
def main_class():
    st1 = MyProcess(name='ST1')
    st2 = MyProcess(name='ST2')
    st1.start()
    st2.start()
# 在主程序入口启动当前子程序
if __name__ == '__main__':
    print('---开始---')
    main_class()
    print('---结束---')
# ---开始---
# ---结束---
# ST1将舒眠4秒
# ST2将舒眠5秒
# ST1醒来
# ST2醒来

2）进程之间的内存空间是隔离的

  • 每一个子进程之间的数据是相互隔离的
  • 在执行子进程代码时，只修改自己进程内的数据，不会影响到其他的子进程
from multiprocessing import Process

num = 100
# 创建子进程程序
def work():
    global num
    num = 80
    print(f'子进程的num：{num}')
# 在主程序入口启动当前子程序
if __name__ == '__main__':
    st1 = Process(target=work)
    print(f'原始num：{num}')
    st1.start()
    print(f'start后的num：{num}')
    st1.join()
    print(f'join后的num：{num}'
# 原始num：100
# 子进程的num：80
# start后的num：100
# join后的num：100

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

客户端（client）

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()}")

服务端（server）

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(5)
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()

【六】Process对象的join方法

  • 将并行转串行
  • 即子进程逐个进行

1.join的串行

import multiprocessing
import random
import time


# 创建子进程程序
def work(name):
    sleep_time = random.randint(1, 6)
    print(f'{name}将舒眠{sleep_time}秒')
    time.sleep(sleep_time)
    print(f'{name}醒来')


def join_run():
    task_list = [multiprocessing.Process(
        target=work,
        args=(f'ST{i}',)) for i in range(5)]
    for task in task_list:
        task.start()
        task.join()


# 在主程序入口启动当前子程序
if __name__ == '__main__':
    start_time = time.time()
    print('---开始---')
    join_run()
    print('---结束---')
    end_time = time.time()
    print(f'总耗时 :{end_time - start_time}s')
# ---开始---
# ST0将舒眠1秒
# ST0醒来
# ST1将舒眠1秒
# ST1醒来
# ST2将舒眠1秒
# ST2醒来
# ST3将舒眠1秒
# ST3醒来
# ST4将舒眠6秒
# ST4醒来
# ---结束---
# 总耗时 :10.425310850143433s

2.join的并行

import multiprocessing
import random
import time


# 创建子进程程序
def work(name):
    sleep_time = random.randint(1, 6)
    print(f'{name}将舒眠{sleep_time}秒')
    time.sleep(sleep_time)
    print(f'{name}醒来')


def join_run():
    task_list = []
    for i in range(5):
        task = multiprocessing.Process(
            target=work,
            args=(f'ST{i}',)
        )
        task.start()
        task_list.append(task)
    for task in task_list:
        task.join()


# 在主程序入口启动当前子程序
if __name__ == '__main__':
    start_time = time.time()
    print('---开始---')
    join_run()
    print('---结束---')
    end_time = time.time()
    print(f'总耗时 :{end_time - start_time}s')
# ---开始---
# ST2将舒眠3秒
# ST0将舒眠1秒
# ST1将舒眠2秒
# ST3将舒眠6秒
# ST4将舒眠2秒
# ST0醒来
# ST1醒来
# ST4醒来
# ST2醒来
# ST3醒来
# ---结束---
# 总耗时 :6.116597414016724s
posted on 2024-05-21 19:51  晓雾-Mist  阅读(5)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 晓雾-Mist
Powered by .NET 8.0 on Kubernetes