计算机发展史与进程

目录

  • 1.操作系统发展史

    • 1).穿孔卡片
    • 2).联机批处理系统
    • 3).脱机批处理系统
    • 4).多道技术
  • 2.进程
    • 程序与进程
    • 进程调度:
    • 程序运行时的三个状态;
    • 同步和异步:
    • 阻塞与非阻塞:
  • 创建进程的两种方式
    • 方式一:定义一个任务
    • 方式二:自定义一个类,并继承Process

1.操作系统发展史

1).穿孔卡片

? 一个机房一次只能使用一个卡片
? CPU使用率极低

2).联机批处理系统

? 支持多用户使用一个计算机机房。

3).脱机批处理系统

? 高速磁带提升了读取的速度,提高了CPU的利用率。

4).多道技术

单道:

(单核情况下)多个用户使用CPU时是串行的,一个一个执行,只有一个程序执行完成才能执行下一个程序 。

多道

(基于单核情况下):在程序A,就在内存中加载程序B,当程序A使用完CPU后B就开始使用CPU(也是只有一个CPU)。

(1).空间上的复用

? 一个淳朴可以提供给多个用户去使用。

(2).时间上的复用(******)

? 切换+保存状态(切换时保存程序当前的执行状态)

? IO操作:input()、print()、time.sleep().

? 1).若CPU遇到IO操作,会立即切断当前执行的程序CPU的使用权
? 优点:CPU的利用率高

? 2).若一个程序使用CPU的时间过长(有设定的cup最常使用时间),立即将当前程序的CPU使用权断开,交给其他程序使用。
? 缺点:降低了程序的执行率。

并发与并行:

? 并发:看起来像同时在运行。(相当于多个程序来回切换)

? 并行:真实的同时运行,在多核的情况下同时执行多个程序。

2.进程

程序与进程

? 程序:一堆代码
? 进程:一堆代码运行的过程

进程调度:

? 1.先来先服务调度:
? a,b程序,若a程序先来,先占用CPU

? 缺点:程序a先使用,程序b必须一直等待
? 2.短作业优先调度:
? a,b程序,谁的时间短,优先调度谁使用

? 缺点:必须等待所有用时短的程序使用结束才能执行用时长的

? 3.时间片轮转法
? CPU执行的时间1秒钟,加载n个程序,要将1秒等分成n个时间片(n份)
? 4.分级反馈队列
? 将执行优先分为多层级别
? ——1级:优先级最高
? ——2级:次之,以此类推
? ——3级

程序运行时的三个状态;

? 就绪态:所有程序创建时都会进入此状态,准备调度。

? 运行态:调度后的进程,进入运行态。

? 阻塞态:凡是遇到IO操作的进程,都会进入阻塞态。若IO结束,必须重新进入就绪态。

同步和异步:

? 指的是提交任务的方式。
? 同步: 若有两个任务需要提交,在提交第一个任务时任务时,必须等待该任务执行结束才能执行下一个任务。
? 异步:若有两个任务提交,第二个任务不需要等待,两个任务可以同时进行。

#同步演示程序:程序一直在运行,并未将CPU的运行权限交出去
import time

def test():
    # IO操作
    # time.sleep(3)

    # 计算操作
    num = 1
    for line in range(1000000000000000000000000):
        num += 1

if __name__ == '__main__':
    test()
    print('hello tank')

阻塞与非阻塞:

? 阻塞:阻塞态,遇到IO定会阻塞
? 非阻塞: 就绪态、 运行态

? 面试题:同步异步,阻塞非阻塞是同一个概念吗?
? 等待不一定是阻塞,有可能某个任务占用CPU的时间过长, 所以他们不是同一个概念,不能混为一谈!

? 最大化提高CPU的使用率:尽可能减少不必要的IO操作

创建进程的两种方式

方式一:定义一个任务

在Windows系统下易发生的错误,子进程创建时会调用父进程的程序,父进程执行时又调用子进程,这样一直下去,造成了递归(windows会把复制的代码当做导入文件)。这种问题只有在Windows系统里才会出现(Windows系统执行创建子进程的任务时,会将当前父进程代码重新加载执行一次),在Mac系统和Linux系统里面会将当前子进程代码重新拷贝一份,单独执行。

import time
from multiprocessing import Process

def task(name):
    print(f'{name}的任务开始执行')
    time.sleep(1)
    print(f'{name}的任务已经结束')
#target=执行函数的地址,agrs里面填元组,且元素是task的函数的参数
p = Process(target=task,args=('jason',))
#向操作系统提交创建进程的任务
p.start()
print('主进程')

将子进程写在main函数里面运行程序是就不会先运行父进程,而是从main函数开始运行(main函数里面是子进程),这样就不会出现递归的问题了。

import time
from multiprocessing import Process

def task(name):
    print(f'{name}的任务开始执行')
    time.sleep(1)
    print(f'{name}的任务已经结束')

if __name__ == '__main__':
    #target=执行函数的地址,agrs里面填元组,且元素是task的函数的参数
    p = Process(target=task,args=('jason',))
    #向操作系统提交创建进程的任务
    p.start()
    print('主进程')

方式二:自定义一个类,并继承Process

这里主进程和子进程是并行运行的,他们之间互不影响,各自运行各自的。


from multiprocessing import Process
import time

class MyProcess(Process):

    def run(self):
        print('任务开始执行')
        time.sleep(1)
        print('任务已经结束')

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

主进程
任务开始执行
任务已经结束

join方法

作用:告诉操作系统,让子进程结束后,父进程在结束。

from multiprocessing import Process
import time

class MyProcess(Process):

    def run(self):
        print('任务开始执行')
        time.sleep(1)
        print('任务已经结束')

if __name__ == '__main__':
    p = MyProcess()
    p.start()#告诉操作系统,开启子进程
    p.join()#告诉操作系统,等子进程结束后,父进程再结束
    print('主进程')

任务开始执行
任务已经结束
主进程

当开启多个子进程时要用多个join

import time
from multiprocessing import Process

def task(name,n):
    print(f'{name}的任务开始执行')
    time.sleep(n)
    print(f'{name}的任务已经结束')

if __name__ == '__main__':
    #target=执行函数的地址,agrs里面填元组,且元素是task的函数的参数
    p1 = Process(target=task,args=('jason',1))
    p2 = Process(target=task, args=('xiaoming',2))
    p3 = Process(target=task, args=('xiaohua',3))
    #向操作系统提交创建进程的任务
    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()
    print('主进程')
jason的任务开始执行
xiaoming的任务开始执行
xiaohua的任务开始执行
jason的任务已经结束
xiaoming的任务已经结束
xiaohua的任务已经结束
主进程

进程间的数据是相互隔离的,子进程和主进程会产生各自的名称空间,在执行的时候互不影响。

x = 100
def func():
    print('执行func函数。。。')
    global x
    x = 200
    print(f'子程序x:{x}')

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(f'主程序x{x}')

主程序x100
执行func函数。。。
子程序x:200

关于进程号

进程号是进程在执行时,操作系统给随机分配的一窜数字,这串数字是有限的,如果操作系统用尽了所有的进程号则系统将不能再有新的进程运行。

courent_process().pid:获取子进程号

os.getpid():获取主进程pid号

os.getppid():获取主进程的父进程(p for parent)

cmd中查看进程号:tasklist|findstr 进程号

进程号回收的两种条件:

1.join,可以回收子进程与主进程。

2.主进程正常结束,子进程与主进程也会被回收。

检查子进程是否存活的方法

子进程.is_alive() 返回的是bool值True or False

终止子进程的方法

子进程.terminate() 让操作系统强行终止子进程

from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
    print(f'{name} start...', current_process().pid)
    time.sleep(1)
    print(f'{name} over..', current_process().pid)

if __name__ == '__main__':
    p = Process(target=task, args=('jason', ))
    p.start()  # 告诉操作系统,开启子进程

    # 判断子进程是否存活
    print(p.is_alive())

    # 直接告诉操作系统,终止 子进程
    #p.terminate()
    time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的,而打印操作是在主进程中进行的,如果不暂停的话有可能,主进程执行到最后一步时,子进程还没执行到强制终止的指令,这样就无法得到正确的打印接过了

    # 判断子进程是否存活
    print(p.is_alive())

    p.join()  # 告诉操作系统,等子进程结束后,父进程再结束。
True
True
jason start... 8988
jason over.. 8988

加入终止子进程程序后

from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
    print(f'{name} start...', current_process().pid)
    time.sleep(1)
    print(f'{name} over..', current_process().pid)

if __name__ == '__main__':
    p = Process(target=task, args=('jason', ))
    p.start()  # 告诉操作系统,开启子进程

    # 判断子进程是否存活
    print(p.is_alive())

    # 直接告诉操作系统,终止 子进程
    p.terminate()
    time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的,而打印操作是在主进程中进行的,如果不暂停的话有可能,主进程执行到最后一步时,子进程还没执行到强制终止的指令,这样就无法得到正确的打印接过了

    # 判断子进程是否存活
    print(p.is_alive())

    p.join()  # 告诉操作系统,等子进程结束后,父进程再结束。

True
False

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

? 僵尸进程:子进程已经结束,但pid号还存在未销毁,

? 缺点:占用pid号,占用资源。

? 孤儿进程:指的是子进程还在执行但父进程意外结束。

? 操作系统提供一个福利院,帮忙回收没有父进程的子进程,这就是守护进程。

守护进程

指主进程结束后,该主进程产生的所有子进程也跟着结束并回收。

from multiprocessing import Process
import time
from multiprocessing import current_process
def task(name):
    print(f'{name} start...', current_process().pid)
    time.sleep(1)
    print(f'{name} over..', current_process().pid)

if __name__ == '__main__':
    p = Process(target=task, args=('jason', ))
    p.daemon = True# True代表该进程是守护进程
    p.start()  # 告诉操作系统,开启子进程

    # 判断子进程是否存活
    print(p.is_alive())

    # 直接告诉操作系统,终止 子进程
    p.terminate()
    time.sleep(0.1)#此处让子进程暂停0.1秒是因为子进程与主进程是并行执行的,而打印操作是在主进程中进行的,如果不暂停的话有可能,主进程执行到最后一步时,子进程还没执行到强制终止的指令,这样就无法得到正确的打印接过了

    # 判断子进程是否存活
    print(p.is_alive())

    p.join()  # 告诉操作系统,等子进程结束后,父进程再结束。

?

原文地址:https://www.cnblogs.com/ghylpb/p/11715195.html

时间: 2024-10-31 17:12:50

计算机发展史与进程的相关文章

计算机发展史(转)

计算机发展史 话不多说,直接带大家一起感受这段波澜壮阔的历史. 1642年 法国 帕斯卡(B.Pascal)发明的机械计算机,可用于计算加减法. 1834年 英国 查尔斯·巴贝奇设计了分析机,采用打孔纸带作为输入输出方式. 1842年 英国 阿达·洛芙莱斯(Ada Lovelace)发明了第一个计算机程序,用于在分析机上计算伯努利数,建立了循环和子程序概念. 1936年 英国 艾伦·图灵提出了"图灵机"的理论模型,为现代计算机的逻辑工作方式奠定基础. 1937年 世界上第一台电子计算机

计算机发展史 进程

多道技术 1.空间上的复用: 多个程序共用一套计算机硬件 2.时间上的复用: 切换+保存状态 1.当一个程序遇到IO操作,操作系统会剥夺该程序的cpu执行权限(提高了cpu的利用率 并且也不影响程序的执行效率) 2.当一个程序长时间占用cpu 操作系统也会剥夺该程序的cpu执行权限(降低了程序的执行效率) 并发:看起来像同时运行的就可以       并行:真正意义上的同时执行            单核的计算机能不能实现并行,但是可以实现并发 同步异步:表示的是任务的提交方式        同步

计算机发展史(多道技术)

1.串行: 一个任务完完整整地运行完毕后,才能运行下一个任务 2.并发(伪并行) 看起来多个任务是同时运行的即可,单核也可以实现并发 3.并行: 真正意义上多个任务的同时运行,只有多核才实现并行 4.cpu的功能: cpu是用来做计算,cpu是无法执行IO操作的,一旦遇到io操作,应该让cpu去执行别的任务 5.多道技术(针对单核而言) 1.多道技术的实现是为了解决多个程序竞争或者说共享同一个资源(比如cpu)的有序调度问题,  解决方式即多路复用,多路复用分为时间上的复用和空间上的复用. 1.

计算机发展史及(python3入门)

1. 操作系统的历史 第一代计算机: 特点: a. 在一定的时间内,程序员独享整个计算机的资源 b. 没有操作系统的概念, 直接操作的是硬件设备 缺点: a. 浪费计算机资源,一个时间段内只有一个人用. b. 同一时刻只有一个程序在内存中,被cpu调用执行,比方说10个程序的执行,是串行的 第二代计算机: 特点: a. 批处理系统解决一个人使用的问题 缺点: 1.整个流程需要人参与控制,将磁带搬来搬去(中间俩小人) 2.计算的过程仍然是顺序计算->串行 3.程序员原来独享一段时间的计算机,现在必

「MoreThanJava」计算机发展史—从织布机到IBM

「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 不论新老朋友 我相信您都可以 从中获益.如果觉得 「不错」 的朋友,欢迎 「关注 + 留言 + 分享」,文末有完整的获取链接,您的支持是我前进的最大的动力! 一.织布机 | 一切的开端 如今代表智能现代的计算机与老式织布机的血缘关系超乎你的想象.无论是摆在写字台上的 台式机.塞在口袋里的 掌上电脑.

020002_计算机发展史

一.什么是计算机? 计算机(computer)俗称电脑,是现代一种用于高速计算的电子计算机器,可以进行数值计算,又可以进行逻辑计算,还具有存储记忆功能,是能够按照程序运行,自动.高速处理海量数据的现代化智能电子设备. 程序自动化:可以将预先编好的程序组纳入计算机内存,在程序控制下,计算机可以连续.自动地工作,不需要人的干预. 高速:当今计算机系统的运算速度已达到每秒万亿次,普通电脑也可达每秒亿次以上,使大量复杂的科学计算问题得以解决. 二.计算机的发展过程 1946年2月14日,世界上第一台电子

计算机发展史

long long ago 老祖宗的算盘 ...数百年之后.... 1623 1623年,德国科学家契克卡德(Wilhelm Schickard)制造能够进行6位数的加减运算,是为了帮助自己的挚友天文学家开普勒(kepler)做机械运算,但是这个发明很晚世人发现. 1642 法国科学家帕斯卡为了帮助父亲费力的计算税率税款,19岁的帕斯卡研发出一种系列齿轮组成的,外壳用黄铜材料制作,长20英寸宽4英寸高3英寸的厂方盒子计算器,面板上有一列显示数字的小窗口,旋紧发条后才能转动, 用专用的铁笔来拨动转

002_计算机发展史和未来方向

计算工具的演化经历了由简单到复杂.从低级到高级的不同阶段,例 ENIAC计算机 如从"结绳记事"中的绳结到算筹.算盘计算尺.机械计算机等.它们在不同的历史时期发挥了各自的历史作用,同时也启发了现代电子计算机的研制思想. 1889年,美国科学家赫尔曼·何乐礼研制出以电力为基础的电动制表机,用以储存计算资料. 1930年,美国科学家范内瓦·布什造出世界上首台模拟电子计算机. 1946年2月14日,由美国军方定制的世界上第一台电子计算机"电子数字积分计算机"(ENIAC

计算机基础知识——进程、线程、程序

一.进程和线程的区别是什么? 进程是执行着的应用程序,而线程是进程内部的一个执行序列.一个进程可以有多个线程.线程又叫做轻量级进程. 线程与进程的区别归纳: a.地址空间和其它资源:进程间相互独立,同一进程的各线程间共享.某进程内的线程在其它进程不可见. b.通信:进程间通信IPC,线程间可以直接读写进程数据段(如全局变量)来进行通信——需要进程同步和互斥手段的辅助,以保证数据的一致性. c.调度和切换:线程上下文切换比进程上下文切换要快得多. d.在多线程OS中,进程不是一个可执行的实体. h