操作系统发展史 & 进程

今日内容

  • UDP协议
  • 操作系统发展史
  • 进程
    • 单核情况下的进程调度
    • 进程三状态图
    • 同步异步
    • 阻塞非阻塞

内容详细

一、UDP协议

1、什么是UDP协议

UDP是传输层的协议,功能即为在IP的数据报服务之上增加了最基本的服务:复用和分用以及差错检测。

UDP提供不可靠服务,具有TCP所没有的优势:

  • UDP无连接,时间上不存在建立连接需要的时延。

  • UDP没有拥塞控制,应用层能够更好的控制要发送的数据和发送时间,网络中的拥塞控制也不会影响主机的发送速率。

2、案例

import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)  # UDP协议
udp_sk.bind(('127.0.0.1',9000))  # 绑定地址
msg,addr = udp_sk.recvfrom(1024)
udp_sk.sendto(b'hi',addr)             
udp_sk.close() 


import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

"""
时间服务器的实现原理
	1.内部小电容供电
	2.远程时间同步
"""

例子:简易qq程序

二、操作系统发展史

操作系统发展史就是围绕着提高CPU利用率发展的,每次技术的进步,CPU的利用率就大大提高

"""学习并发编程其实就是在学习操作系统的发展史(底层逻辑)"""

1、穿孔卡片时代

CPU利用率极低

使用计算机的人要拿着自己的程序(穿孔卡片)在门外等候,输入时间非常长,CPU利用时间就少

2、联机批处理系统

将多个程序员的程序一次性录入磁带中 之后交由输入机输入并由CPU执行

3、脱机批处理系统

现代计算机的雏形(远程输入 高速磁带 主机)

工作人员只需要买一台输入设备在家,就可以把程序传输到高速磁带中(内存),然后再用CPU执行

多道技术

前提是单核CPU

  • 切换+保存状态

切换:CPU在执行进程代码时,如果遇到进行IO操作会立刻停止当前进程的执行,切换到其它进程的执行中去

保存状态:在切换之前,会保留当前进程的执行状态,以便切换回来时可以在断开处继续

'''
CPU工作机制:
	1、当某个程序进入IO操作状态时,操作系统会强行剥夺该程序的CPU执行权限
	2、当某个程序长时间占用CPU时,操作系统也会强行剥夺该程序的CPU执行权限
'''


并行与并发:
	并行:多个程序同时运行(每个程序执行都需要一个CPU)
    并发:多个程序只要看起来像是同时运行的就可以

# 问:单核CPU能否实现并行
	肯定不能,但是可以实现并发
# 问:12306可以同一时间支持几个亿的用户买票 问是并行还是并发
	肯定是并发(高并发)		
星轨:微博能够支持八个星轨

三、进程

1、什么是进程

程序:实现功能的编程代码,存在硬盘中(是死的)

进程:运行中的应用程序,存在内存中(是活的)

2、单核情况下的进程调度

  • FCFS 先来先服务

对短作业不友好

  • 启动时间短先启动

对长作业不友好

  • 时间片轮转法 + 多级反馈队列

1、先给所有要执行的进程分配相同的时间片(CPU执行时间)

2、然后根据每个进程消耗的时间片多少进行分级,需要执行时间长的进入下一级

3、优先执行第一级需要时间片少的进程

进程的三状态图

image

3、同步异步

同步

CPU 提交任务之后原地等待返回信息,再去执行其它任务

异步

提交任务之后不会等待,先去执行其它任务,接收到返回信息后再回来执行,有反馈机制

4、阻塞非阻塞

阻塞

阻塞态:IO操作、异常断开

非阻塞

就绪态与执行态

四、代码层面创建进程

1、创建进程两种方式

直接创建进程对象(主要的)

from multiprocessing import Process
import time
import os


def run(name):
    print(os.getpid()) # 获取进程号
    print(os.getppid()) # 获取父进程号
    print('%s is running ' % name)
    time.sleep(3)
    print('%s is over' % name)


if __name__ == '__main__':
    p = Process(target=run, arg=('elijah', ))  # 生成一个进程对象
    p.start()  # 告诉操作系统要启动这个子进程,然后继续执行主进程   异步提交
    print(os.getpid())
    print('主进程')


'''
在windows中开设进程类似于导入模块
	代码自上而下执行
一定要在__main__判断语句内执行开设进程的代码
否则,被导入模块也会执行开设进程的代码,这样会陷入死循环
'''
'''
在linux中是直接将代码完整地复制一份执行
	不用在__main__判断语句中执行
'''

用类创建进程对象

class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s正在运行' % self.name)
        time.sleep(3)
        print('%s已经结束' % self.name)

if __name__ == '__main__':
    p = MyProcess('jason')
    p.start()
    print('主')

2、进程的 join 方法

主进程开设子进程之后,等待子进程执行完成之后再往下执行

from multiprocessing import Process
import time


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


if __name__ == '__main__':
    start_time = time.time()
    process_list = []
    for i in range(1, 4):
        p = Process(target=run, args=(i, i))
        p.start()
        process_list.append(p)
    for p in process_list:
        p.join()

    print(time.time() - start_time)

    print('主进程')


# 运行结果
    1 is running
    2 is running
    3 is running
    1 is over
    2 is over
    3 is over
    3.309438943862915	# 执行时间
    主进程

'''
当第一个 p.join() 执行时,只有主进程会在原地等待它执行结束
其它两个子进程并不受影响,会继续执行
所以总的时间是最长的那个子进程执行时间
'''

3、进程之间默认无法交互

主程序开设子程序,相当于再开辟了一块内存重新执行一遍代码(以被导入模块执行,__main__判断语句内的代码不会执行),那它执行修改数据操作不会影响到主进程的数据,因为进程之间默认无法进行交互

from multiprocessing import Process

money = 100


def test():
    global money
    money = 90


if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    p.join()
    print(money)

# 执行结果
100

4、进程对象方法

1.current_process查看进程号
2.os.getpid() 查看进程号  os.getppid() 查看父进程进程号
3.进程的名字,p.name直接默认就有,也可以在实例化进程对象的时候通过关键字形式传入name=''
3.p.terminate()  杀死子进程 
4.p.is_alive()  判断进程是否存活	3,4结合看不出结果,因为操作系统需要反应时间。主进程睡0.1即可看出效果
posted @ 2022-01-13 22:14  elijah_li  阅读(40)  评论(0编辑  收藏  举报
//一下两个链接最好自己保存下来,再上传到自己的博客园的“文件”选项中