Introduction à Python day38-concurrent synchrone et asynchrone

Un: examen des connaissances nécessaires

1. Bases de l'ordinateur

计算机 又称之为 电脑，即 通电的大脑，发明计算机 是为了让它通电之后 能够像人一样去工作，并且它比人的工作效率更高，因为可以24小时不间断

2. Les cinq principaux composants d'un ordinateur

控制器
运算器
存储器
输入设备
输出设备
    
计算机的核心真正干活的是CPU（控制器+运算器+存储器）

3. Si le programme veut être exécuté par l'ordinateur, son code doit être lu du disque dur à la mémoire, puis le CPU récupère les instructions et s'exécute

Deux: les détails d'aujourd'hui

1. L'histoire du développement du système d'exploitation

Les premiers ordinateurs, cartes perforées pour stocker des données

Système de traitement par lots en ligne

Système de traitement par lots hors ligne

参考博客即可：https://www.cnblogs.com/Dominic-Ji/articles/10929381.html

2. Technologie multicanal

Un noyau unique produit un effet simultané

必备知识点：
    1.并发
        看起来像同时运行的就可以称之为“并发”
    2.并行
        真正意义上的 同时执行
    PS：
        并行肯定算并发
        单核的计算机肯定不能实现并行，但是可以实现并发
    补充：
        我们直接假设：单核就是一个核，干活的就是一个人，不要考虑CPU里面的内核数

3. Illustration technique multicanal

Économisez le temps total passé à exécuter plusieurs programmes

4. Connaissances clés de la technologie multicanal

Multiplexage spatial et multiplexage temporel

空间上的复用：

    多个程序公用一套计算机硬件

时间上的复用：

    例子1：洗衣机30S，做饭50S，烧水30S          切换节省时间
        单道：110S
        多道：50S，多道只需要任务最长的那一个
        
    例子2：边吃饭边玩游戏                       保存状态

Noyau:

切换 + 保存状态
'''
    切换（CPU）分为2种情况：
        1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限
            作用：提高了CPU的利用率，并且也不影响程序的执行效率
        2.当一个程序长时间占用CPU的时候，操作系统也会剥夺该程序的CPU执行权限
            作用：降低了程序的执行效率（原本时间+切换时间）
'''

5. Théorie des processus

Points de connaissances requis:

程序与进程的区别
'''
    程序 就是一堆躺在硬盘上的代码，是“死”的
    进程 则表示程序正在执行的过程，是“活”的
'''

Planification des processus:

先来先服务 调度算法
'''
    对长作业有利，对短作业无益
'''

短作业优先调度算法
'''
    对短作业有利，对长作业无益
'''

Méthode de rotation de tranche de temps + file d'attente de rétroaction à plusieurs niveaux

Diagramme à trois états du processus en cours

Trois: deux paires de concepts importants

Synchrone et asynchrone:

描述的是 任务的提交方式

同步：任务提交之后，原地等待任务的返回结果，等待的结果中不做任何事（干等着）
	程序层面上 表现出来的感觉 就是卡住了

异步：任务提交之后，不原地等待任务的返回结果，直接去做其他事情，等待任务的返回结果自动提交给调用者
	我提交的任务结果如何获取？
	任务的返回结果 会有一个异步回调机制自动处理

Exemple de synchronisation:

import time


def func(): time.sleep(3) print('Hello World') if __name__ == '__main__': res = func() # 同步调用 res print('hahah') 

Blocage et non blocage:

描述的是 程序的运行状态

阻塞：阻塞态

非阻塞：就绪态、运行态

理想状态：我们应该让我们写的代码 永远处于 就绪态 和 运行态 之间切换

La combinaison des concepts ci-dessus: la combinaison la plus efficace est  asynchrone + non bloquante

Quatre: 2 façons de démarrer le processus

Tranquillité d'esprit: la façon dont le code démarre les processus et les threads, l'écriture du code est fondamentalement la même, vous apprenez à démarrer les processus, vous apprenez à démarrer les threads

Le premier:

from multiprocessing import Process
import time


def task(name): print(f'{name}' ' is running') time.sleep(3) print(f'{name}' ' is over') # task(1) if __name__ == '__main__': # 创建进程的代码 # 1.创建一个对象 p = Process(target=task, args=('xxq',)) # 容器类型 无论里面有几个元素，一定要用逗号隔开，哪怕里面只有一个 # 2.开启进程 p.start() # 告诉操作系统 帮你创建一个进程 # 异步的感觉 print('主进程') ''' Windows操作系统下 创建进程一定要在main内创建 因为Windows下创建进程 类似于 模块导入的方式 会从上往下 依次执行代码 Linux中则是直接将代码 完整地拷贝一份 ''' 

Le deuxième type:

# 第二种：

import time
from multiprocessing import Process
 class MyProcess(Process): def run(self): print('Hello Beautiful Girl!') time.sleep(1) print('Get out') if __name__ == '__main__': p = MyProcess() p.start() print('主') 

Résumé:

创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去
一个进程对应在内存中就是一块独立的内存空间
多个进程对应在内存中就是多块独立的内存空间
进程与进程之间数据默认情况下是无法直接交互,如果想交互可以借助于第三方工具、模块

Cinq: méthode de jointure

La jointure consiste à laisser le processus principal attendre que le code du sous-processus se termine avant de continuer. N'affecte pas l'exécution d'autres processus enfants

Première édition:

from multiprocessing import Process
import time


def task(name): print(f'{name}' ' is running') time.sleep(1) print(f'{name}' ' is over') if __name__ == '__main__': p1 = Process(target=task, args=('xxq1',)) p2 = Process(target=task, args=('xxq2',)) p3 = Process(target=task, args=('xxq3',)) start_time = time.time() p1.start() p2.start() p3.start() print('主进程', time.time() - start_time) xxq3 is running xxq1 is running xxq2 is running xxq1 is over xxq3 is over xxq2 is over 

Version avancée:

from multiprocessing import Process
import time


def task(name): print(f'{name}' ' is running') time.sleep(3) print(f'{name}' ' is over') if __name__ == '__main__': p1 = Process(target=task, args=('xxq1',)) p2 = Process(target=task, args=('xxq2',)) p3 = Process(target=task, args=('xxq3',)) start_time = time.time() p1.start() p2.start() p3.start() # time.sleep(5) p1.join() # 主进程等待子进程p结束之后再继续往后执行 p2.join() # 主进程等待子进程p结束之后再继续往后执行 p3.join() # 主进程等待子进程p结束之后再继续往后执行 print('主进程', time.time() - start_time) 

Version finale:

from multiprocessing import Process
import time


def task(name, n): print(f'{name}' ' is running') time.sleep(n) print(f'{name}' ' is over') if __name__ == '__main__': start_time = time.time() p_list = [] for i in range(1, 4): p = Process(target=task, args=(f'{i}', i)) p.start() p_list.append(p) for p in p_list: p.join() print('主进程', time.time() - start_time) # 输出： # 2 is running # 1 is running # 3 is running # 1 is over # 2 is over # 3 is over # 主进程 3.214817762374878 # 先全部同时执行，再关闭