操作系统的发展与进程初识

一.操作系统

1.os组成

os组成包括硬件和软件

硬件：主机（CPU + 存储器），I/O设备

软件：系统软件，应用软件

2.os发展史

脱机批处理系统：单道批处理系统与多道批处理系统。

单道批处理系统：

优点：缩短了手工操作的时间，提高了CPU的利用率

缺点：

半自动化，不提供人机交互能力，需要人参与，给用户使用带来了不便

计算过程是串行，限制了即使系统的使用效率

必须等所有文件处理完，才返回结果，降低了程序的开发效率

多道批处理系统：运用了多道技术的批处理系统

特点：遇到IO操作就切换程序，使得cpu的利用率提高了。解决CPU的速度与I/O速度不匹配的矛盾

时空复用：

空间复用：把内存分成多个独立的小内存空间，一个空间执行一个程序

时间复用：不同的程序或用户轮流使用它

技术的实现：

中断：使正在运行的程序让出CPU

状态保存：用PSW保存系统被中断时的状态，放入PCB池中

优点：提高了CPU的运行效率

分时操作系统：使用分时技术的操作系统。

时间片：操作系统将CPU的时间划分成若干个片段

分时技术：按时间片轮流把CPU分给多个程序使用

特点：

多路性：若干个用户同时使用一台计算机。

交互性：实现人机交互

独立性：用户之间可以相互独立操作，互不干扰

及时性：能做出及时响应

优点：提高多个程序的共同效率

缺点：降低了单个程序的处理效率

实时操作系统：

定义：在确定性的时间内，执行完程序，并返回相应的结果。

           一般多用在与军事相关的操作系统上

二.进程

进程：程序关于某数据集合的一次运行活动，是OS进行资源分配和调度的基本单位

进程实体结构：

数据结构P

内存代码C

内存数据D

通用寄存器R

程序状态字信息PSW

进程三态：

就绪态：当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

运行态：当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

阻塞态：正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态

挂起态：

使用前提：使用前提：计算机系统在运行过程中出现资源不足时候

资源不足表现为：性能低和死锁

定义：剥夺进程占有内存及其他资源，不参与进程调度，被os或程序主动结束挂起态后，再从硬盘调入内存并恢复其他资源，参与调度

挂机态与阻塞态的区别：

阻塞态：在内存中处于等待

挂起态：不占据内存，所有数据储存在硬盘中

同步与异步

同步：任务提交之后 原地等待的任务的执行并拿到返回结果才走 期间不做任何事

异步：任务提交之后 不再原地等待 而是继续执行下一行代码

阻塞与非阻塞

阻塞：阻塞态

非阻塞：就绪态 运行态

进程同步

互斥锁 ：

使用前提：当多个进程操作同一份数据的时候 会造成数据的错乱

使用限制：锁必须在主进程中产生 交给子进程去使用

加锁处理把程序的并发运行变成了串行，虽然降低了效率但是提高了数据的安全

锁的使用会增加程序的复杂度，也容易造成死锁现象

from multiprocessing import Process,Lock
import time
import json

# 查票
def search(i):
    with open('data','r',encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    print('用户%s查询余票为:%s'%(i,t_d.get('ticket')))

# 买票
def buy(i):
    with open('data','r',encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    time.sleep(1)
    if t_d.get('ticket') > 0:
        # 票数减一
        t_d['ticket'] -= 1
        # 更新票数
        with open('data','w',encoding='utf-8') as f:
            json.dump(t_d,f)
        print('用户%s抢票成功'%i)
    else:
        print('没票了')


def run(i,mutex):
    search(i)
    mutex.acquire()  # 抢锁  只要有人抢到了锁 其他人必须等待该人释放锁
    buy(i)
    mutex.release()  # 释放锁


if __name__ == '__main__':
    mutex = Lock()  # 生成了一把锁
    for i in range(10):
        p = Process(target=run,args=(i,mutex))
        p.start()

三.multiprocessing模块

Process类的介绍

方法介绍

 1 p.start()：启动进程，并调用该子进程中的p.run() 
 2 p.run():进程启动时运行的方法我们自定义类的类中一定要实现该方法  
 
 3 p.terminate():强行终止进程p，不会先解锁再清除，容易造成死锁，及子进程成为僵尸进程。

 4 p.is_alive():判断进程是否存活

 5 p.join([timeout]):主线程等待p终止

属性介绍

1 p.daemon：默认值为False。如果设为True，代表p为守护进程，父程序终止时，P程序也会被终止。守护进程不能创建自己的进程，并且必须在start方法之前设置

2 p.name:进程的名称
 
3 p.pid：进程的id

4 p.exitcode:进程运行时为值None、为–N时，表示被信号N结束

 创建进程

 from multiprocessing import Process
 import time


 def test(name):
     print('%s is running'%name)
     time.sleep(3)
     print('%s is over'%name)


# windows创建进程会将代码以模块的方式 从上往下执行一遍
# linux会直接将代码完完整整的拷贝一份
#

 if __name__ == '__main__':
     p = Process(target=test,args=('egon',))  # 创建一个进程对象
    p.start()  # 告诉操作系统帮你创建一个进程
     print('主')

from multiprocessing import Process
import time


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

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


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