并发编程

# 操作系统的发展历程
    # 主要的人机矛盾是什么 : CPU的使用率
        # 输入输出数据和CPU计算没有关系
    # 操作系统是怎么进化的
        # 传统的纸带输入
        # 磁带的存储降低了输入输出数据占用的时间,提高了CPU的利用率
        # 多道操作系统的出现 : 提高了CPU的利用率,单纯的切换会浪费时间
            # 一台计算机上同时可以出现多个任务
            # 能够将多个任务所使用的资源隔离开
            # 当一个任务遇到输入输出工作的时候能够让另一个任务使用CPU去计算
        # 分时操作系统 : 降低了cpu的利用率,提高了用户的体验
            # 时间片轮转
        # 实时操作系统
            # 操作精密仪器或者设备
            # 实时交易类
    # 操作系统的作用
        # 在具体的应用与所有的硬件之间起到了一个协调管理的作用
        # 负责分配计算机中所有的资源

# 输入输出 Input/Output
    # 向内存输入 : read,recv,recvfrom,import,input
    # 从内存输出 : write,send,sendto,print
# CPU的工作效率和输入输出的工作效率差

# 并发和并行
    # 多个程序交替在同一个cpu上被计算 并发
    # 多个程序同时在多个cpu上被计算   并行
# 阻塞/非阻塞
    # 阻塞 CPU不工作
    # 非阻塞 CPU一直在工作
# 异步和同步
    # 异步 :发布一个任务,不等待这个任务的结果就继续执行我的任务
    # 同步 :发布一个任务,等待获取这个任务的结果之后才继续执行我的任务
# 同步阻塞/同步非阻塞/异步阻塞/异步非阻塞

# 进程和程序
    # 进程就是运行中的程序
    # 每一个进程在计算机中都有一个唯一的进程id,pid  process id
# 进程  是计算机中资源分配的最小单位
    # 三状态 : 就绪 运行 阻塞
# 线程  是计算机中能够被CPU调度的最小单位
    # 是进程中的一个单位,它不能独立存在

使用Process类创建一个子进程
import os
import time
from multiprocessing import Process
def func(a,b,c):
    time.sleep(1)
    print(a,b,c,os.getpid(),os.getppid())
    # pid : processid   ppid : parent process id

# Process进程类
if __name__ == '__main__':
    # windows操作系统下开启子进程子进程中的代码是通过import这种方式被导入到子进程中的
    print('主 :', os.getpid())
    Process(target=func,args=(1,2,3)).start()
    # Process(target=func).start()
    # Process(target=func).start()

如何开启多个子进程

import os
import time
from multiprocessing import Process
def func(a,b,c):
    time.sleep(1)
    print(a,b,c,os.getpid(),os.getppid())
if __name__ == '__main__':
    # Process(target=func,args=(1,2,3)).start()
    # Process(target=func,args=(2,3,4)).start()
    # Process(target=func,args=(3,4,5)).start()
    for i in  range(1,4):
        Process(target=func, args=(i, i+1, i+2)).start()

join方法

import time
import random
from multiprocessing import Process

def send_mail(name):
    time.sleep(random.uniform(1,3))
    print('已经给%s发送邮件完毕'%name)

if __name__ == '__main__':
    lst = ['alex','yuan','宝元','太白']
    阻塞等待一个子进程结束
    p = Process(target=send_mail, args=('alex',))
    p.start()
    p.join()   # 阻塞,直到p对应的进程结束之后才结束阻塞
    print('所有的信息都发送完毕了')

    p_l = []
    for name in lst:
        p = Process(target=send_mail,args=(name,))
        p.start()
        p_l.append(p)
    for p in p_l : p.join()
    print('所有的信息都发送完毕了')

守护进程

import time
from multiprocessing import Process
def func():
    for i in range(20):
        time.sleep(0.5)
        print('in func')

def func2():
    print('start : func2')
    time.sleep(5)
    print('end : func2')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True   # 表示设置p为一个守护进程
    p.start()
    p2 =Process(target=func2)
    p2.start()
    print('in main')
    time.sleep(3)
    print('finished')
    p2.join()

# 主进程和子进程互不干扰
# 主进程执行完毕之后程序不会结束,会等待所有的子进程结束之后才结束
# 为什么主进程要等待子进程结束之后才结束?
    # 因为主进程要负责给子进程回收一些系统资源
# 守护进程 :
    # 是一个子进程,守护的是主进程
    # 结束条件 : 主进程的代码结束,守护进程也结束
# 进程
    # 主进程的代码结束,守护进程结束
    # 主进程要回收守护进程(子进程)的资源
    # 主进程等待其他所有子进程结束
    # 主进程回收所有子进程的资源

面向对象的方式实现多进程

import os
from multiprocessing import Process
class MyProcess(Process):
    def run(self):   # 希望在子进程中执行的代码就放在run方法中
        print(os.getpid())

if __name__ == '__main__':
    for i in range(10):
        MyProcess().start()

import os
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,a,b):
        super().__init__()
        self.a = a
        self.b = b

    def run(self):   # 希望在子进程中执行的代码就放在run方法中
        print(os.getpid(),self.a,self.b)
        self.func()
if __name__ == '__main__':
    for i in range(10):
        MyProcess(1,2).start()   # 通知操作系统开进程,执行run方法