1、学习建议

  • 要懂得取舍，没必要所有的知识都啃的很透 

    1. """这个东西是什么，能用来干嘛，怎么用"""

  • 一定要培养自我解决问题的能力 

    1. """
    2. 遇到一个问题之后一定要先给自己设置一个解决改问题的时间限
    3. 30分钟之内我自己解决
    4.  百度
    5. 30分钟到一个小时问朋友，同学
    6.  讨论
    7. 一个小时以上
    8.  问老师
    9. """

2、必备知识回顾

  • 计算机又叫电脑，即通电的大脑，发明计算机是为了让他通电之后能够像人一样去工作，并且它比人的工作效率更高，因为可以24小时不间断
  • 计算机五大组成部分
    控制器
    运算器
    存储器
    输入设备
    输出设备
    计算机的核心真正干活的是CPU(控制器+运算器=中央处理器)
  • 程序要想被计算机运行，它的代码必须要先由硬盘读到内存，之后cpu取指再执行

3、今日内容详细

3.1、操作系统发展史

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

3.2、多道技术

单核实现并发的效果

3.2.1 必备知识点

  • 并发
    看起来像同时运行的就可以称之为并发
  • 并行
    真正意义上的同时执行

ps:

  • 并行肯定算并发
  • 单核的计算机肯定不能实现并行，但是可以实现并发！！！

补充：我们直接假设单核就是一个核，干活的就一个人，不要考虑cpu里面的内核数

3.2.2 多道技术图解

节省多个程序运行的总耗时

参考群内截图

3.2.3 多道技术重点知识

空间上的服用与时间上的服用

  • 空间上的复用
    多个程序公用一套计算机硬件
  • 时间上的复用
    例子:洗衣服30s，做饭50s，烧水30s
    单道需要110s，多道只需要任务做长的那一个 切换节省时间
    例子:边吃饭边玩游戏 保存状态

切换+保存状态

  1. """
  2. 切换(CPU)分为两种情况
  3.     1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限
  4.         作用:提高了CPU的利用率 并且也不影响程序的执行效率
  6.     2.当一个程序长时间占用CPU的时候，操作吸引也会剥夺该程序的CPU执行权限
  7.         弊端:降低了程序的执行效率(原本时间+切换时间)
  8. """

4、进程理论

4.1 必备知识点

程序与进程的区别

  1. """
  2. 程序就是一堆躺在硬盘上的代码，是“死”的
  3. 进程则表示程序正在执行的过程，是“活”的
  4. """

4.2 进程调度

  • 先来先服务调度算法 

    1. """对长作业有利，对短作业无益"""

  • 短作业优先调度算法 

    1. """对短作业有利，多长作业无益"""

  • 时间片轮转法+多级反馈队列
    参考图解

4.3 进程运行的三状态图

image.png
参考图解了解即可

4.4 两对重要概念

  • 同步和异步
    ```python “””描述的是任务的提交方式””” 同步:任务提交之后，原地等待任务的返回结果，等待的过程中不做任何事(干等) 程序层面上表现出来的感觉就是卡住了

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

  2. -  **阻塞非阻塞**  
  3. ```python
  4. """描述的程序的运行状态"""
  5. 阻塞:阻塞态
  6. 非阻塞:就绪态、运行态
  8. 理想状态:我们应该让我们的写的代码永远处于就绪态和运行态之间切换

上述概念的组合:最高效的一种组合就是异步非阻塞

5、开启进程的两种方式

定心丸:代码开启进程和线程的方式，代码书写基本是一样的，你学会了如何开启进程就学会了如何开启线程

  1. from multiprocessing import Process
  2. import time
  5. def task(name):
  6.     print('%s is running'%name)
  7.     time.sleep(3)
  8.     print('%s is over'%name)
  11. if __name__ == '__main__':
  12.     # 1 创建一个对象
  13.     p = Process(target=task, args=('jason',))
  14.     # 容器类型哪怕里面只有1个元素 建议要用逗号隔开
  15.     # 2 开启进程
  16.     p.start()  # 告诉操作系统帮你创建一个进程  异步
  17.     print('主')
  20. # 第二种方式 类的继承
  21. from multiprocessing import Process
  22. import time
  25. class MyProcess(Process):
  26.     def run(self):
  27.         print('hello bf girl')
  28.         time.sleep(1)
  29.         print('get out!')
  32. if __name__ == '__main__':
  33.     p = MyProcess()
  34.     p.start()
  35.     print('主')

总结

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

5.1 join方法

join是让主进程等待子进程代码运行结束之后，再继续运行。不影响其他子进程的执行

  1. from multiprocessing import Process
  2. import time
  5. def task(name, n):
  6.     print('%s is running'%name)
  7.     time.sleep(n)
  8.     print('%s is over'%name)
  11. if __name__ == '__main__':
  12.     # p1 = Process(target=task, args=('jason', 1))
  13.     # p2 = Process(target=task, args=('egon', 2))
  14.     # p3 = Process(target=task, args=('tank', 3))
  15.     # start_time = time.time()
  16.     # p1.start()
  17.     # p2.start() 
  18.     # p3.start()  # 仅仅是告诉操作系统要创建进程
  19.     # # time.sleep(50000000000000000000)
  20.     # # p.join()  # 主进程等待子进程p运行结束之后再继续往后执行
  21.     # p1.join()
  22.     # p2.join()
  23.     # p3.join()
  24.     start_time = time.time()
  25.     p_list = []
  26.     for i in range(1, 4):
  27.         p = Process(target=task, args=('子进程%s'%i, i))
  28.         p.start()
  29.         p_list.append(p)
  30.     for p in p_list:
  31.         p.join()
  32.     print('主', time.time() - start_time)

5.2 进程之间数据相互隔离

  1. from multiprocessing import Process
  4. money = 100
  7. def task():
  8.     global money  # 局部修改全局
  9.     money = 666
  10.     print('子',money)
  13. if __name__ == '__main__':
  14.     p = Process(target=task)
  15.     p.start()
  16.     p.join()
  17.     print(money)