4.22

课程安排

1. 并发编程 3~4天
2. 项目 2~3天
3. MySQL ~5天
4. 前端 ~7天
5. django框架 ~10天
6. bbs项目 3~5天
7. 代码发布 ~5天
8. cmdb ~5天

学习建议

1. 学会取舍，没必要所有知识点都钻研透
2. 培养自我解决问题的能力

今日内容

1. 操作系统发展史
2. 多道技术
3. 进程理论
4. 开启进程的两种方式
5. 进程对象的join方法
6. 进程之间数据相互隔离
7. 进程对象的其他方法
8. 僵尸进程与孤儿进程
9. 守护进程
10. 互斥锁

操作系统发展史

• 手工操作：穿孔卡片

  同一时间机房只有一个人操作，cpu等待手工操作，资源的利用率低

• 联机批处理系统

  节省了每个用户插卡片的等待时间

• 脱机批处理系统

  提高数据从硬盘读取到内存的速度，减少cpu等待的时间

多道技术

• 并发

  看起来像同时运行的就可以称之为并发

• 并行

  真正意义上的同时执行，也是并发

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

  我们直接假设单核就是一个核，干活的就只有一个人

多道技术：节省了多个程序运行的总耗时

重点知识

空间上的复用与时间上的复用

• 空间上的复用：多个程序公用一套计算机硬件

• 时间上的复用：

  例：洗衣服50min，做饭20min，烧水5min。。。

  单道执行，需要所有时间总和的运行时间，多道只需要时间最长的那个时间

切换程序 + 保存状态

切换分为两种情况
  - 当一个程序遇到IO操作系统的时候，操作系统会剥夺该程序的CPU执行权限：提高了cpu的利用率，并且也不影响程序的执行效率
  - 当一个程序长时间占用cpu的时候，操作系统也会剥夺该程序的cpu执行权限：降低了程序的执行效率

进程理论

程序与进程的区别

• 程序就是一堆在硬盘里的代码，是死的
• 进程表示程序在内存中正在执行的过程，是活的

进程调度

• 先来先服务调度算法：对长作业有利，对短作业不利

  现在这种算法已经被淘汰

• 短作业优先调度算法：对短作业有利，对长作业不利

• 时间片轮转法：当你要打开新程序的时候会停下当前在执行的先把你新程序给他开

进程运行的三状态图

所有的程序想要被执行必须先经历就绪态

事件请求包括input，print，open一类

阻塞态到就绪态：input获取到值，文件读取完成，timesleep结束

两对重要概念

同步和异步

描述的是任务的提交方式

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

• 异步：任务提交之后，不原地等待任务的返回结果，直接去做其他事情，等待任务的返回结果

  任务的返回结果会有一个异步的回调机制

阻塞和非阻塞

描述的是程序的运行状态

• 阻塞：阻塞态
• 非阻塞：就绪态，运行态

最高效的一种组合就是异步+非阻塞

理想状态：我们应该让我们写的代码永远处于就绪态和运行态，没有阻塞

开启进程的两种方式

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

第一种方式

p = Proccess(target=task, args=('deimos',))

from multiprocessing import Process
import time
def task(name):
	print('%s is running'%name)
	time.sleep(2)
	print('%s is over'%name)
	
if __name__ == '__main__':
	# 1. 创建一个对象
	p = Proccess(target=task, args=('deimos',))
	# 2. 开启进程
	p.start() # 告诉操作系统要创建一个进程
	print('main')
	# 运行，则创建两个进程，一个是task，一个是main

windows操作系统下，创建进程一定要在main内创建，因为windows下创建进程类似于模块导入的方式，会从上往下执行

第二种方式：类的继承

from multiprocessing import Process
import time
class MyProcess(Process):
	def run(self):
		print('sleep')
		time.sleep(1)
		print('get up')
		
if __name__ == '__main__':
	p = Myprocess()
	p.start()
	print('main')

第一种方式用的比较多

总结

创建进程就是在内存中申请一块内存空间，将需要运行的代码丢进去，一个进程对应在内存中就是一块独立的内存空间，多个进程对应的是多块独立的内存空间

进程与进程之间的数据在默认状态下无法直接交互，如果想交互可以借助别的工具，模块

join方法

主进程等待子进程结束之后，再继续往后执行

结果就是把异步变成同步

from multiprocessing import Process
import time


def task(name, n):
    print('%s is running'%name)
    time.sleep(n)
    print('%s is over'%name)


if __name__ == '__main__':
    # p1 = Process(target=task, args=('jason', 1))
    # p2 = Process(target=task, args=('egon', 2))
    # p3 = Process(target=task, args=('tank', 3))
    # start_time = time.time()
    # p1.start()
    # p2.start()
    # p3.start()  # 仅仅是告诉操作系统要创建进程
    # # time.sleep(50000000000000000000)
    # # p.join()  # 主进程等待子进程p运行结束之后再继续往后执行
    # p1.join()
    # p2.join()
    # p3.join()
    start_time = time.time()
    p_list = []
    for i in range(1, 4):
        p = Process(target=task, args=('子进程%s'%i, i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('主', time.time() - start_time)

进程之间数据相互隔离

标签：__,name,start,python,笔记,print,time,进程,4.22
来源： https://www.cnblogs.com/telecasterfanclub/p/12753162.html