每日测验

  • 阐述同步异步阻塞非阻塞概念
  • 手写开启进程的两种方式

昨日内容回顾

如何复习知识点:总分总

先列出提纲，再依次复习，最后再总结一下

  • 操作系统的发展史

    1. """
    2. 其实主要就是围绕cpu的利用率问题
    3. """

  • 多道技术

    ```python “”” 单核实现并发的效果

并发:看起来像同时运行的就可以叫做并发 并行:真正意义上的同时运行

ps:明显出轨 >>>: 星轨

空间与时间上的复用 空间上 多个程序公用一套计算机硬件 时间上 切换+保存状态 “””

切换分为两种

1.当一个程序遇到IO操作,操作系统会立刻剥夺该程序的cpu执行权限(提供了cpu利用率并且不影响程序的执行效率)

2.当一个程序长时间占用cpu，操作系统也会立刻剥夺该程序的cpu执行权限(降低了程序的运行效率但是玩出了并发的效果)

  2. -    
  3. <a name="f88522cf"></a>
  4. ### 进程
  5. ```python
  6. """
  7. 程序就是一堆死代码     死
  8. 进程则是正在执行的过程  活
  9. """
  11. # 进程的调度算法
  12. """
  13. 先来先服务调度算法
  14. 短作业优先调度算法
  15. 时间片轮转法+多级反馈队列
  16. """

  • 进程运行的三状态图

    1. """
    2. 就绪态:一切程序必须要先过就绪态才能加入运行态
    3. 运行态:正在被cpu执行
    4. 阻塞态:程序遇到IO操作了
    5. 理想:我们希望我开发的程序一致处于就绪态与运行态之间
    6. """

  • 两对重要概念

    • 同步与异步 

      1. """任务的提交方式"""
      2. 同步
      3. 任务提交之后原地等待任务的返回结果期间不做任何事情
      4. 异步
      5. 任务提交之后不原地等待任务的返回结果执行执行下一行代码
      6. 结果由异步回调机制做处理

    • 阻塞非阻塞
      上面的两对概念通常会组合出现，但是最常用的就是异步非阻塞 

      1. """程序的运行状态"""
      2. 阻塞:阻塞态
      3. 非阻塞:就绪态  运行态

  • 开启进程的两种方式

    ```python “”” from mutiprocessing import Process

1 类实例化产生对象

2 类的继承 run方法

再windows里面开启进程的代码一定要写在main代码块内

创建一个进程就是在内存空间中申请一块内存空间将需要的代码丢进去 “””

  2. -    
  3. <a name="c4c9d3b5"></a>
  4. ### join方法
  5. ```python
  6. """
  7. 主进程等待子进程代码运行完毕后再往下执行代码
  8. """

  • 进程间数据是相互隔离的(默认情况下)

ps:人工智能相关参考网站

http://www.turingapi.com/

https://www.xfyun.cn/?ch=bd05&b_scene_zt=1

http://ai.baidu.com/creation/main/demo

作为一名python程序员当你遇到一个功能的时候，第一时间你可以考虑是否有对应的模块已经帮你实现了该功能

今日内容概要

  • 进程对象及其他方法
  • 僵尸进程与孤儿进程
  • 守护进程
  • 互斥锁
  • 队列介绍
  • 进程间通信IPC机制
  • 生产者消费者模型
  • 线程相关知识点

今日内容详细

如果你的pycharm老是过期，你可以直接下载最新版本的pycharm，然后加入一个网站获取激活码即可

http://idea.medeming.com/jets/

进程对象及其他方法

  1. """
  2. 一台计算机上面运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？
  3. 计算机会给每一个运行的进程分配一个PID号 
  4. 如何查看
  5.     windows电脑 
  6.         进入cmd输入tasklist即可查看
  7.         tasklist |findstr PID查看具体的进程
  8.     mac电脑 
  9.         进入终端之后输入ps aux
  10.         ps aux|grep PID查看具体的进程 
  11. """
  12. from multiprocessing import Process, current_process
  13. current_process().pid  # 查看当前进程的进程号
  15. import os
  16. os.getpid()  # 查看当前进程进程号
  17. os.getppid()  # 查看当前进程的父进程进程号
  20. p.terminate()  # 杀死当前进程
  21. # 是告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快
  22. time.sleep(0.1)
  23. print(p.is_alive())  # 判断当前进程是否存活

僵尸进程与孤儿进程(了解)

  1. # 僵尸进程
  2. """
  3. 死了但是没有死透
  4. 当你开设了子进程之后 该进程死后不会立刻释放占用的进程号
  5. 因为我要让父进程能够查看到它开设的子进程的一些基本信息 占用的pid号 运行时间。。。
  6. 所有的进程都会步入僵尸进程
  7.     父进程不死并且在无限制的创建子进程并且子进程也不结束
  8.     回收子进程占用的pid号
  9.         父进程等待子进程运行结束
  10.         父进程调用join方法
  11. """
  13. # 孤儿进程
  14. """
  15. 子进程存活，父进程意外死亡
  16. 操作系统会开设一个“儿童福利院”专门管理孤儿进程回收相关资源
  17. """

守护进程

一起死一起活

  1. from multiprocessing import Process
  2. import time
  5. def task(name):
  6.     print('%s总管正在活着'% name)
  7.     time.sleep(3)
  8.     print('%s总管正在死亡' % name)
  11. if __name__ == '__main__':
  12.     p = Process(target=task,args=('egon',))
  13.     # p = Process(target=task,kwargs={'name':'egon'})
  14.     p.daemon = True  # 将进程p设置成守护进程  这一句一定要放在start方法上面才有效否则会直接报错
  15.     p.start()
  16.     print('皇帝jason寿终正寝')

互斥锁

多个进程操作同一份数据的时候，会出现数据错乱的问题

针对上述问题，解决方式就是加锁处理:将并发变成串行，牺牲效率但是保证了数据的安全

  1. from multiprocessing import Process, Lock
  2. import json
  3. import time
  4. import random
  7. # 查票
  8. def search(i):
  9.     # 文件操作读取票数
  10.     with open('data','r',encoding='utf8') as f:
  11.         dic = json.load(f)
  12.     print('用户%s查询余票：%s'%(i, dic.get('ticket_num')))
  13.     # 字典取值不要用[]的形式 推荐使用get  你写的代码打死都不能报错！！！
  16. # 买票  1.先查 2.再买
  17. def buy(i):
  18.     # 先查票
  19.     with open('data','r',encoding='utf8') as f:
  20.         dic = json.load(f)
  21.     # 模拟网络延迟
  22.     time.sleep(random.randint(1,3))
  23.     # 判断当前是否有票
  24.     if dic.get('ticket_num') > 0:
  25.         # 修改数据库 买票
  26.         dic['ticket_num'] -= 1
  27.         # 写入数据库
  28.         with open('data','w',encoding='utf8') as f:
  29.             json.dump(dic,f)
  30.         print('用户%s买票成功'%i)
  31.     else:
  32.         print('用户%s买票失败'%i)
  35. # 整合上面两个函数
  36. def run(i, mutex):
  37.     search(i)
  38.     # 给买票环节加锁处理
  39.     # 抢锁
  40.     mutex.acquire()
  42.     buy(i)
  43.     # 释放锁
  44.     mutex.release()
  47. if __name__ == '__main__':
  48.     # 在主进程中生成一把锁 让所有的子进程抢 谁先抢到谁先买票
  49.     mutex = Lock()
  50.     for i in range(1,11):
  51.         p = Process(target=run, args=(i, mutex))
  52.         p.start()
  53. """
  54. 扩展 行锁 表锁
  56. 注意：
  57.     1.锁不要轻易的使用，容易造成死锁现象(我们写代码一般不会用到，都是内部封装好的)
  58.     2.锁只在处理数据的部分加来保证数据安全(只在争抢数据的环节加锁处理即可) 
  59. """

进程间通信

队列Queue模块

  1. """
  2. 管道:subprocess 
  3.     stdin stdout stderr
  4. 队列:管道+锁
  6. 队列:先进先出
  7. 堆栈:先进后出
  8. """
  9. from multiprocessing import Queue
  11. # 创建一个队列
  12. q = Queue(5)  # 括号内可以传数字 标示生成的队列最大可以同时存放的数据量
  14. # 往队列中存数据
  15. q.put(111)
  16. q.put(222)
  17. q.put(333)
  18. # print(q.full())  # 判断当前队列是否满了
  19. # print(q.empty())  # 判断当前队列是否空了
  20. q.put(444)
  21. q.put(555)
  22. # print(q.full())  # 判断当前队列是否满了
  24. # q.put(666)  # 当队列数据放满了之后 如果还有数据要放程序会阻塞 直到有位置让出来 不会报错
  26. """
  27. 存取数据 存是为了更好的取
  28. 千方百计的存、简单快捷的取
  30. 同在一个屋檐下
  31. 差距为何那么大
  32. """
  34. # 去队列中取数据
  35. v1 = q.get()
  36. v2 = q.get()
  37. v3 = q.get()
  38. v4 = q.get()
  39. v5 = q.get()
  40. # print(q.empty())
  41. # V6 = q.get_nowait()  # 没有数据直接报错queue.Empty
  42. # v6 = q.get(timeout=3)  # 没有数据之后原地等待三秒之后再报错  queue.Empty
  43. try:
  44.     v6 = q.get(timeout=3)
  45.     print(v6)
  46. except Exception as e:
  47.     print('一滴都没有了!')
  49. # # v6 = q.get()  # 队列中如果已经没有数据的话 get方法会原地阻塞
  50. # print(v1, v2, v3, v4, v5, v6)
  52. """
  53. q.full()
  54. q.empty()
  55. q.get_nowait()
  56. 在多进程的情况下是不精确
  57. """

IPC机制

  1. from multiprocessing import Queue, Process
  3. """
  4. 研究思路
  5.     1.主进程跟子进程借助于队列通信
  6.     2.子进程跟子进程借助于队列通信
  7. """
  8. def producer(q):
  9.     q.put('我是23号技师 很高兴为您服务')
  12. def consumer(q):
  13.     print(q.get())
  16. if __name__ == '__main__':
  17.     q = Queue()
  18.     p = Process(target=producer,args=(q,))
  19.     p1 = Process(target=consumer,args=(q,))
  20.     p.start()
  21.     p1.start()

生产者消费者模型

  1. """
  2. 生产者:生产/制造东西的
  3. 消费者:消费/处理东西的
  4. 该模型除了上述两个之外还需要一个媒介
  5.     生活中的例子做包子的将包子做好后放在蒸笼(媒介)里面，买包子的取蒸笼里面拿
  6.     厨师做菜做完之后用盘子装着给你消费者端过去
  7.     生产者和消费者之间不是直接做交互的，而是借助于媒介做交互
  9. 生产者(做包子的) + 消息队列(蒸笼) + 消费者(吃包子的)
  10. """

线程理论

致命三问

  • 什么是线程
    ```python “”” 进程:资源单位 线程:执行单位

将操作系统比喻成一个大的工厂 那么进程就相当于工厂里面的车间 而线程就是车间里面的流水线

每一个进程肯定自带一个线程

再次总结: 进程:资源单位(起一个进程仅仅只是在内存空间中开辟一块独立的空间) 线程:执行单位(真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程索要)

进程和线程都是虚拟单位，只是为了我们更加方便的描述问题 “””

  2. -  为何要有线程  
  3. ```python
  4. """
  5. 开设进程
  6.     1.申请内存空间    耗资源
  7.     2.“拷贝代码”   耗资源
  8. 开线程
  9.     一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间操作
  11. 总结:
  12.     开设线程的开销要远远的小于进程的开销
  13.     同一个进程下的多个线程数据是共享的!!!
  14. """
  15. 我们要开发一款文本编辑器
  16.     获取用户输入的功能
  17.   实时展示到屏幕的功能
  18.   自动保存到硬盘的功能
  19. 针对上面这三个功能，开设进程还是线程合适？？？
  20.     开三个线程处理上面的三个功能更加的合理
  • 如何使用

今日作业

  • 整理今日内容到博客
    描述知识点一定要用自己的话术概括，不要死记硬背！！！
    把知识点理解了，再去用自己语言组织说出来即可
  • 手动书写生产者消费者代码
  • 思考:如何实现TCP服务端并发的效果