精华内容
下载资源
问答
  • docker进程管理(1号进程,僵尸进程详解)
    千次阅读
    2021-03-12 18:05:07

    前沿

    大家都知道对linux系统来说1号进程为init进程,是由0号进程(内核进程)通过调用系统init函数创建的第一个用户进程1进程,主要做用户态进程的管理,垃圾回收等动作。
    对docker来讲1号进程大多数情况下都是服务进程,或者是用户自己开发的服务daemon进程,这也是瘦容器的理论,那服务进程作为1号进程有什么区别呢?
    本文详细讲述1号进程的区别,如何规避僵尸进程等

    docker的进程管理

    docker进程管理的基础是LINUX内核中的PID命名空间技术,在不同PID名空间中,进程ID是独立的;即在两个不同名空间下的进程可以有相同的PID。
    在Docker中,每个Container都是Docker Daemon的子进程,每个Container进程缺省都具有不同的PID名空间。通过名空间技术,Docker实现容器间的进程隔离。
    当创建一个Docker容器的时候,就会新建一个PID名空间。容器启动进程在该名空间内PID为1。当PID1进程结束之后,Docker会销毁对应的PID名空间,并向容器内所有其它的子进程发送SIGKILL。

    下面通过例子具体看docker进程情况:
    容器内执行ps -ef,可以看到1号进程为服务daemon进程redisadmin及其子进程redis-server

    [root@localhost ~]# docker exec 61570e71c903 ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:01 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:00 redis-server *:6379
    
    

    在宿主机上通过docker top container_id可以看到容器内进程,从下面可以卡看到1号进程redisadmin在宿主机上父进程为docker daemon

    [root@localhost ~]# docker top 61570e71c903
    UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
    2000                436                 32147               0                   07:48               ?                   00:00:00            redis-server *:6379
    2000                32147               32130               0                   06:50               pts/4               00:00:01            python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    
    • 知识1:通过exec执行的docker命令,父进程为0号进程,也就是docker daemon进程,容器内的0号进程,不是1号进程。 但是由exec启动的进程属于容器的namespace和相应的cgroup
       [root@localhost ~]# docker exec -ti 61570e71c903 bash   用bash进入容器
       [hitv@localhost data]$ ps -ef
       UID        PID  PPID  C STIME TTY          TIME CMD
       hitv         1     0  0 06:50 ?        00:00:01 python3 /usr/local/bin/redisadmi
       hitv      4398     1  0 07:48 ?        00:00:00 redis-server *:6379
       hitv      5056     0  0 07:57 ?        00:00:00 bash   发现bash的父进程为0号
       [hitv@localhost data]$ exit
       [root@localhost ~]# docker exec 61570e71c903 sleep 1000&  用exec到docker里后台执行sleep
       [root@localhost ~]# docker exec 61570e71c903 ps -ef
       UID        PID  PPID  C STIME TTY          TIME CMD
       hitv         1     0  0 06:50 ?        00:00:01 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
       hitv      4398     1  0 07:48 ?        00:00:00 redis-server *:6379
       hitv      5125     0  0 07:58 ?        00:00:00 sleep 1000    发现sleep进程的父进程也是0号
    
    

    上面的这个结论在下面将僵尸进程时会用到,请留意

    • 知识点2:由于PID1进程的特殊性,Linux内核为他做了特殊处理。如果它没有提供某个信号的处理逻辑,那么与其在同一个PID名空间下的进程发送给它的该信号都会被屏蔽。这个功能的主要作用是防止init进程被误杀
        [root@localhost ~]# docker exec 61570e71c903 kill -9 1
        [root@localhost ~]# docker exec 61570e71c903 ps -ef
        UID        PID  PPID  C STIME TTY          TIME CMD
        hitv         1     0  0 06:50 ?        00:00:01 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
        hitv      4398     1  0 07:48 ?        00:00:00 redis-server *:6379
        hitv      5125     0  0 07:58 ?        00:00:00 sleep 1000
        hitv      5545     0  0 08:04 ?        00:00:00 ps -ef
    
    
    上面可以看到执行kill -9是没用的,是杀不掉1号进程的,验证了上面的知识点2
    如果要想能在容器内执行kill干掉1号进程,需要在1号进程中实现信号接收处理,比如收到kill -15执行exit操作,python例子如下
    
        def sigterm_handler(sig, frame):
            logging.info("get term signal({0})".format(sig))
            if sig == 15:
                logging.info("get kill -15, exit")
                sys.exit(1)
    
        signal.signal(signal.SIGTERM, sigterm_handler)
    
    • 附加知识点: 自从Docker 1.5之后,docker run命令引入了–pid=host参数来支持使用宿主机PID名空间来启动容器进程,这样可以方便的实现容器内应用和宿主机应用之间的交互:比如利用容器中的工具监控和调试宿主机进程。

    指定docker的1号进程

    可以被Dockerfile中的ENTRYPOINT或CMD指令所指明;也可以被docker run命令的启动参数所覆盖
    这里主要描述在ENTRYPOINT和CMD指令中,提供两种不同的进程执行方式 shell 和 exec

    • shell 方式 CMD executable param1 param2
        CMD redisadmin -d startup -P 6379 -f
    
    注意:如果redisadmin是shell脚本,则启动方式为/bin/sh -c ”redisadmin -d startup -P 6379 -f”,这样1号进程就为/bin/sh,1号进程中拉起的redisadmin -d startup -P 6379 -f
    但是我的redisadmin为python的,首行写的#!/usr/bin/env python3,所以从上面例子可以看到1号进程为python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    这样实际上跟exec方式一样了。
    
    • exec 方式 CMD [“executable”,“param1”,“param2”] 这种方式跟run命令的启动参数覆盖的1号进程一样,写的什么什么就是1号进程
    • 这两种方式的具体不同在哪里?
      • 这里就用到了进程管理那部分的知识,PID1进程对于操作系统而言具有特殊意义。操作系统的PID1进程是init进程,以守护进程方式运行,是所有其他进程的祖先,具有完整的进程生命周期管理能力。在Docker容器中,PID1进程是启动进程,它也会负责容器内部进程管理的工作。而这也将导致进程管理在Docker容器内部和完整操作系统上的不同。
      • 不同1: 到底谁负责进程管理,比如我redisadmin为1号,我在里面写了很多子进程处理的代码,但是shell方式他的1号进程是bash,就会导致无法做处理了
      • 不同2:Docker提供了两个命令docker stop和docker kill来向容器中的PID1进程发送信号
        • 当执行docker stop命令时,docker会首先向容器的PID1进程发送一个SIGTERM信号,用于容器内程序的退出。如果容器在收到SIGTERM后没有结束, 那么Docker Daemon会在等待一段时间(默认是10s)后,再向容器发送SIGKILL信号,将容器杀死变为退出状态。
          • 也就是说如果我在1号进程实现了SIGTERM(15)信号处理,比如不是上面那样简单的退出自己,而是先优雅的对redis执行shutdown(redis做bgsave保证数据不丢失),然后再sys.exit(1),这样就实现了容器优雅stop
        • 而docker kill可以向容器内PID1进程发送任何信号,缺省是发送SIGKILL信号来强制退出应用,当然这里并不是用exec执行的,上面提到过exec是干不掉1号进程的,这里在宿主机上对1号进程下发的kill

    僵尸进程

    当一个子进程终止后,它首先会变成一个“失效(defunct)”的进程,也称为“僵尸(zombie)”进程,等待父进程或系统收回(reap)。在Linux内核中维护了关于“僵尸”进程的一组信息(PID,终止状态,资源使用信息),从而允许父进程能够获取有关子进程的信息。如果不能正确回收“僵尸”进程,那么他们的进程描述符仍然保存在系统中,系统资源会缓慢泄露。
    僵尸进程:终止的进程但是因为父进程没有垃圾回收功能导致的进程,跟孤儿进程的区别是孤儿进程知识父进程退出了,但是自己还未终止
    孤儿进程:子进程未退出,但是父进程退出了,这种进程会变为孤儿进程,在Linux中Init进程(PID1)作为所有进程的父进程,会维护进程树的状态,一旦有某个子进程成为了“孤儿”进程后,init就会负责接管这个子进程。当一个子进程成为“僵尸”进程之后,如果其父进程已经结束,init会收割这些“僵尸”,释放PID资源。
    下面主要讲解docker中1号进程为服务进程不是init进程时是什么表现,该怎么处理僵尸进程

    情况1: exec启动的进程

    [root@localhost ~]# docker exec 61570e71c903 ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    [root@localhost ~]# docker exec 61570e71c903 sleep 1000 &
    [root@localhost ~]# docker exec 61570e71c903 ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    hitv      8557     0  3 08:45 ?        00:00:00 sleep 1000
    [root@localhost ~]# docker exec 61570e71c903 kill -9 8557
    [1]+  Exit 137                docker exec 61570e71c903 sleep 1000
    [root@localhost ~]# docker exec 61570e71c903 ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    

    由进程管理那部分我们得出的结论是exec执行的进程其父进程是0号进程也就是docker daemon,docker daemon进程有垃圾回收,所以不会产生僵尸进程

    情况2: bash启动的进程,bash进程不退出

    窗口1

    [root@localhost ~]# docker exec -ti 61570e71c903 bash   进入容器
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    hitv      8785     0  2 08:48 ?        00:00:00 bash   这个就为进入容器的bash进程
    [hitv@localhost data]$ sleep 1000&
    [1] 8824
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash
    hitv      8824  8785  0 08:48 ?        00:00:00 sleep 1000  启动sleep进程 发现父进程为bash进程
    
    

    窗口2

    [root@localhost ~]# docker exec -ti 61570e71c903 bash  进入容器
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash    窗口1的bash进程
    hitv      8824  8785  0 08:48 ?        00:00:00 sleep 1000  窗口1bash拉起的sleep进程
    hitv      8874     0  1 08:49 ?        00:00:00 bash  自己窗口的bash进程
    [hitv@localhost data]$ kill -9 8824  kill掉sleep进程
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:02 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:03 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    hitv      8907  8874  0 08:49 ?        00:00:00 ps -ef
    

    从窗口2kill掉sleep进程,发现sleep进程被彻底清理了,这是因为sleep的父进程窗口1的bash进程是有子进程垃圾回收机制的

    情况3:bash启动的进程,bash进程退出

    窗口1

    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash  窗口1bash
    hitv      8874     0  0 08:49 ?        00:00:00 bash  窗口2bash
    [hitv@localhost data]$ sleep 1000&   窗口1启动sleep进程
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmin -d startup -P 6379 -f
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    hitv      9342  8785  0 08:55 ?        00:00:00 sleep 1000 父进程为窗口1bash
    

    窗口2

    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash   窗口1bash
    hitv      8874     0  0 08:49 ?        00:00:00 bash   窗口2bash
    hitv      9342  8785  0 08:55 ?        00:00:00 sleep 1000   窗口1bash启动的sleep
    [hitv@localhost data]$ kill -9 8785   kill掉窗口1bash 让sleep1000成为孤儿进程
    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    hitv      9342     0  0 08:55 ?        00:00:00 sleep 1000  非常震惊的发现孤儿进程被0号进程接管而不是1号进程
    hitv      9435  8874  0 08:56 ?        00:00:00 ps -ef 
    [hitv@localhost data]$ kill -9 9342   kill掉孤儿进程
    [hitv@localhost data]$ ps -ef    发现没有成为僵尸,因为0号进程docker daemon把终止的sleep进程回收了
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    hitv      9526  8874  0 08:57 ?        00:00:00 ps -ef
    
    

    这里的疑问是为什么孤儿进程sleep没被1号进程接管,而是被0号进程接管了呢?
    按照宿主机的理论这里应该要被1号进程接管才对,但是docker表现的是被0号接管了,通过查询资料发现:
    Docker1.11版本之前孤儿进程是由容器内pid为1的进程接收,而1.11版本后是由docker-containerd-shim进程接收,docker-containerd-shim进程时有进程管理功能的,所以这时候kill掉sleep也不会出现僵尸进程
    参考自:https://blog.csdn.net/liukuan73/article/details/78043928

    由上面理论可见docker中产生僵尸进程的唯一一个点就是1号进程拉起的进程,在1号进程没退出且没有子进程管理时的场景
    所以1号进程如果开辟多进程一定要有进程管理功能,下面继续做此验证

    情况4:1号进程拉起的子进程,子进程退出的场景

    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:04 redis-server *:6379
    hitv      8785     0  0 08:48 ?        00:00:00 bash   
    [hitv@localhost data]$ kill -9 4398   kill掉redis进程,等待父进程回收
    [hitv@localhost data]$ ps -ef    
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:03 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:04 [redis-server *:6379] <defunct>
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    

    在1号进程没有没有进程管理时,发现redis进程果然成为了僵尸进程,这是docker出现僵尸进程最常见的场景,所以1号进程一定要有进程管理,下面介绍如何添加子进程清理

    1号进程添加僵尸进程清理

    python为例

    def wait_child(sig, frame):
        try:
            while True:
                #收到信号就检查一下有没有子进程要处理, 其中os.WNOHANG表示不阻塞,就类似于wait()只是不阻塞
                child_pid, status = os.waitpid(-1, os.WNOHANG) 
                if child_pid == 0:
                    logging.debug('No child process need to wait')
                    break
                exitcode = status >> 8
                logging.debug('child process {0} exit, exitcode {1}'.format(child_pid, exitcode))
        except OSError as e:
            # 当没有要处理的子进程时会进入这里
            if e.errno == errno.ECHILD: 
                logging.debug("No child processes")
            else:
                logging.info("wait_child error: {0}".format(e))
    
    
    signal.signal(signal.SIGCHLD, wait_child)  子进程退出时都会向主进程发送SIGCHLD信号,这里捕获这个信号给wait_child()处理
    

    测试

    [hitv@localhost data]$ ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:04 python3 /usr/local/bin/redisadmi
    hitv      4398     1  0 07:48 ?        00:00:07 redis-server *:6379
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    [hitv@localhost data]$ kill -9 4398
    [hitv@localhost data]$ ps -ef   不再僵尸了
    UID        PID  PPID  C STIME TTY          TIME CMD
    hitv         1     0  0 06:50 ?        00:00:04 python3 /usr/local/bin/redisadmi
    hitv      8874     0  0 08:49 ?        00:00:00 bash
    

    总结

    • docker pid1与宿主机pid1有所不同
    • Docker1.11版本之前孤儿进程是由容器内pid为1的进程接收,而1.11版本后是由docker-containerd-shim进程接收,可以减少因1号进程没有子进程处理导致的僵尸进程
    • docker pid1进程的启动也有两种不同,鼓励使用exec避免造成了不符合预期的现象
    • docker exec产生的进程父进程是0号
    • docker pid1进程得实现下信号处理,不然无法在同PID名空间内向其发送信号退出
    • docker pid1进程得实现下子进程清理,避免出现僵尸进程

    参考

    https://www.cnblogs.com/ilinuxer/p/6188303.html
    https://blog.csdn.net/liukuan73/article/details/78043928

    更多相关内容
  • 进程管理

    万次阅读 多人点赞 2021-05-05 22:15:07
    进程管理

    彩蛋 操作系统总目录 戳我

    进程

    进程的概念

    进程的定义

    程序:就是一个指令序列。

    程序段、数据段、PCB三部分组成了进程实体(进程映像)。一般情况下,我们把进程实体就简称为进程,例如,所谓创建进程,实质上是创建进程实体中的PCB;而撤销进程,实质上是撤销进程实体中的PCB。

    PCB是进程存在的唯一标志 !

    从不同的角度,进程可以有不同的定义,比较传统典型的定义有:
    1.进程是程序的一次执行过程
    2.进程是一个程序及其数据在处理机上顺序执行时所发生的活动
    3.进程是具有独立功能的程序在数据集合上运行的过程,它是系统进行资源分配和调度的一个独立单位。

    进程是进程实体的运行过程,是系统进行资源分配和调度的一个独立单位。

    注:严格来说,进程实体和进程并不一样,进程实体是静态的,进程则是动态的。

    进程的组成

    进程(进程实体)由程序段、数据段、PCB三 部分组成。

    在这里插入图片描述

    进程的管理者(操作系统)所需的数据都在PCB中

    程序本身的运行所需的数据存放在程序段和数据段中

    在这里插入图片描述

    PCB

    进程的组织

    在一个系统中,通常有数十、数百乃至数千个PCB。为了能对他们加以有效的管理,应该用适当的方式把这些PCB组织起来。

    注:进程的组成讨论的是一个进程内部由哪些部分构成的问题,而进程的组织讨论的是多个进程之间的组织方式问题

    链接方式

    在这里插入图片描述

    索引方式

    在这里插入图片描述

    进程的特征

    在这里插入图片描述

    小结

    进程状态及转换

    三种基本状态

    进程是程序的一次执行。在这个执行过程中,有时进程正在被CPU处理,有时又需要等待CPU服务,可见,进程的状态是会有各种变化。为了方便对各个进程的管理,操作系统需要将进程合理地划分为几种状态。

    注意:单核处理机环境下,每时刻最多只有一个进程处于运行态。(双核环境下可以同时有两个进程处于运行态)

    进程已经拥有了除处理机之外所有需要的资源,一旦获得处理机,即可立即进入运行态开始运行。即:万事俱备,只欠CPU

    如:等待操作系统分配打印机、等待读磁盘操作的结果。CPU是计算机中最昂贵的部件,为了提高CPU的利用率,需要先将其他进程需要的资源分配到位,才能得到CPU的服务

    另外两种状态

    操作系统需要完成创建进程。操作系统为该进程分配所需的内存空间等系统资源,并为其创建、初始化PCB (如:为进程分配PID)

    进程运行结束(或者由于bug导致进程无法继续执行下去,比如数组越界错误),需要撤销进程。

    操作系统需要完成撤销进程相关的工作。完成将分配给进程的资源回收,撤销进程PCB等工作

    在这里插入图片描述

    进程状态的转换

    在这里插入图片描述

    进程控制

    知识总览

    进程控制的主要功能是对系统中的所有进程实施有效的管理,它具有创建新进程、撤销已有进程、实现进程状态转换等功能。
    简化理解:反正进程控制就是要实现进程状态转换

    在这里插入图片描述

    如何实现进程控制?

    原语实现

    原语是一种特殊的程序,它的执行具有原子性。也就是说,这段程序的运行必须一气呵成,不可中断

    在这里插入图片描述

    思考:为何进程控制(状态转换)的过程要“一气呵成”?

    如果不能“一气呵成”,就有可能导致操作系\统中的某些关键数据结构信息不统一的情况,这会影响操作系统进行别的管理工作。

    Eg:假设PCB中的变量 state 表示进程当前所处状态,1表示就绪态,2表示阻塞态…

    在这里插入图片描述

    假设此时进程2等待的事件发生,则操作系统中,负责进程控制的内核程序至少需要做这样两件事:
    ①将PCB2的 state 设为1
    ②将PCB2从阻塞队列放到就绪队列

    完成了第一步后收到中断信号,那么PCB2的state=1,但是它却被放在阻塞队列里

    如何实现原语的“原子性”?

    原语的执行具有原子性,即执行过程只能一气呵成,期间不允许被中断。
    可以用“关中断指令”和“开中断指令”这两个特权指令实现原子性
    在这里插入图片描述

    正常情况:CPU每执行完一条指令都会例行检查是否有中断信号需要处理,如果有,则暂停运行当前这段程序,转而执行相应的中断处理程序。

    CPU执行了关中断指令之后,就不再例行检查中断信号,直到执行开中断指令之后才会恢复检查。这样,关中断、开中断之间的这些指令序列就是不可被中断的,这就实现了“原子性”

    进程控制相关的原语

    创建原语

    在这里插入图片描述

    撤消原语

    阻塞 唤醒

    进程切换

    知识滚雪球:程序是如何运行的?

    在这里插入图片描述

    • 1

    • 2

    在这里插入图片描述

    • 3

    • 4

    在这里插入图片描述

    解决办法:在进程切换时先在PCB中保存这个进程的运行环境(保存一些必要的寄存器信息)

    进程控制相关的原语

    1. 更新PCB中的信息
      a. 所有的进程控制原语一定都会修改进程状态标志
      b. 剥夺当前运行进程的CPU使用权必然需要保存其运行环境
      c. 某进程开始运行前必然要恢复期运行环境
    2. 将PCB插入合适的队列
    3. 分配 / 回收资源

    如何实现进程控制

    进程通信

    知识总览
    在这里插入图片描述

    什么是进程通信?

    顾名思义,进程通信就是指进程之间的信息交换。

    进程是分配系统资源的单位(包括内存地址空间),因此各进程拥有的内存地址空间相互独立。

    为了保证安全,一个进程不能直接访问另一个进程的地址空间。

    但是进程之间的信息交换又是必须实现的。为了保证进程间的安全通信,操作系统提供了一些方法。

    进程通信——共享存储

    基于数据结构的共享:比如共享空间里只能放一个长度为10的数组。这种共享方式速度慢、限制多,是一种低级通信方式。

    基于存储区的共享:在内存中画出一块共享存储区,数据的形式、存放位置都由进程控制,而不是操作系统。相比之下,这种共享方式速度更快,是一种高级通信方式。

    进程通信——管道通信

    “管道”是指用于连接读写进程的一个共享文件,又名pipe文件。其实就是在内存中开辟一个大小固定的缓冲区

    1. 管道只能采用半双工通信,某一时间段内只能实现单向的传输。如果要实现双向同时通信,则需要设置两个管道。
    2. 各进程要互斥地访问管道。
    3. 数据以字符流的形式写入管道,当管道写满时,写进程的write() 系统调用将被阻塞,等待读进程将数据取走。当读进程将数据全部取走后,管道变空,此时读进程的read() 系统调用将被阻塞。(缓冲区的特性)
    4. 如果没写满,就不允许读。如果没读空,就不允许写。(缓冲区的特性)
    5. 数据一旦被读出,就从管道中被抛弃,这就意味着读进程最多只能有一个,否则可能会有读错数据的情况。

    进程通信——消息传递

    进程间的数据交换以格式化的消息(Message)为单位。进程通过操作系统提供的“发送消息 / 接收消息”两个原语进行数据交换。

    • 直接消息传递:消息直接挂到接收进程的消息缓冲队列上
    • 间接消息传递:消息要先发送到中间实体(信箱)中,因此也称“信箱通信方式”。Eg:计网中的电子邮件系统

    小结

    在这里插入图片描述

    线程

    线程的概念和特点

    知识总览

    什么是线程,为什么要引入线程?

    进程是程序的一次执行。这些功能显然需要用不同的几段程序才能实现,并且这几段程序还要并发运行

    当切换进程时,需要保存 / 恢复进程运行环境,还需要切换内存地址空间(更新快表、更新缓存)开销很大

    引入线程后,线程是CPU调度的基本单位

    线程的优点和特性

    • 进程间并发,开销很大

      1. 当切换进程时,需要保存 / 恢复进程运行环境,还需要切换内存地址空间(更新快表、更新缓存)
    • 线程间并发,开销更小

      1. 同一进程内的各个线程间并发,不需要切换进程运行环境和内存地址空间,省时省力

    引入线程机制后,并发带来的系统开销降低,系统并发性提升

    注意:从属于不同进程的线程间通信,也必须请求操作系统服务!

    引入线程前,进程既是资源分配的基本单位,也是调度的基本单位。

    引入线程后,进程是资源分配的基本单位,线程是调度的基本单位。线程也有运行态、就绪态、阻塞态

    在多CPU环境下,各个线程也可以分派到不同的CPU上并行地执行。

    线程几乎不拥有资源,只拥有极少量的资源(线程控制块TCB、寄存器信息、堆栈等)

    小结

    线程的实现方式多线程模型

    知识总览

    线程的实现方式

    用户级

    历史背景:早期的操作系统(如:早期Unix)只支持进程,不支持线程。当时的“线程”是由线程库实现的

    从代码的角度看,线程其实就是一段代码逻辑。上述三段代码逻辑上可以看作三个“线程”。while 循环就是一个最弱智的“线程库”,线程库完成了对线程的管理工作(如调度)。

    很多编程语言提供了强大的线程库,可以实现线程的创建、销毁、调度等功能。

    1. 线程的管理工作由谁来完成?

    2. 线程切换是否需要CPU变态?

    3. 操作系统是否能意识到用户级线程的存在?

    4. 这种线程的实现方式有什么优点和缺点?

    5. 用户级线程由应用程序通过线程库实现,所有的线程管理工作都由应用程序负责(包括线程切换)

    6. 用户级线程中,线程切换可以在用户态下即可完成,无需操作系统干预。

    7. 在用户看来,是有多个线程。但是在操作系统内核看来,并意识不到线程的存在。“用户级线程”就是“从用户视角看能看到的线程”

    8. 优缺点

      优点:用户级线程的切换在用户空间即可完成,不需要切换到核心态,线程管理的系统
      开销小,效率高

      缺点:当一个用户级线程被阻塞后,整个进程都会被阻塞,并发度不高。多个线程不可在多核处理机上并行运行。


    内核级

    内核级线程(Kernel-Level Thread, KLT, 又称“内核支持的线程”) 由操作系统支持的线程

    在这里插入图片描述

    大多数现代操作系统都实现了内核级线程,如Windows、Linux

    1. 线程的管理工作由谁来完成?

    2. 线程切换是否需要CPU变态?

    3. 操作系统是否能意识到内核级线程的存在?

    4. 这种线程的实现方式有什么优点和缺点?

    5. 内核级线程的管理工作由操作系统内核完成。

    6. 线程调度、切换等工作都由内核负责,因此内核级线程的切换必然需要在核心态下才能完成。

    7. 操作系统会为每个内核级线程建立相应的TCB(Thread Control Block,线程控制块),通过TCB对线程进行管理。“内核级线程”就是“从操作系统内核视角看能看到的线程”

    8. 优缺点

    优点:当一个线程被阻塞后,别的线程还可以继续执行,并发能力强。多线程可在多核处理机上并行执行。

    缺点:一个用户进程会占用多个内核级线程,线程切换由操作系统内核完成,需要切换到核心态,因此线程管理的成本高,开销大。

    多线程模型

    在支持内核级线程的系统中,根据用户级线程和内核级线程的映射关系,可以划分为几种多线程模型

    一对一

    一对一模型:一个用户级线程映射到一个内核级线程。每个用户进程有与用户级线程同数量的内核级线程。

    优点:当一个线程被阻塞后,别的线程还可以继续执行,并发能力强。多线程可在多核处理机上并行执行。

    缺点:一个用户进程会占用多个内核级线程,线程切换由操作系统内核完成,需要切换到核心态,因此线程管理的成本高,开销大。

    多对一

    多对一模型:多个用户级线程映射到一个内核级线程。且一个进程只被分配一个内核级线程。

    优点:用户级线程的切换在用户空间即可完成,不需要切换到核心态,线程管理的系统开销小,效率高

    缺点:当一个用户级线程被阻塞后,整个进程都会被阻塞,并发度不高。多个线程不可在多核处理机上并行运行

    操作系统只“看得见”内核级线程,因此只有内核级线程才是处理机分配的单位。

    多对多

    多对多模型:n 用户及线程映射到m 个内核级线程(n >= m)。每个用户进程对应 m 个内核级线程。

    克服了多对一模型并发度不高的缺点(一个阻塞全体阻塞),又克服了一对一模型中一个用户进程占用太多内核级线程,开销太大的缺点。

    # 可以这么理解:
    # 用户级线程是“代码逻辑”的载体
    # 内核级线程是“运行机会”的载体
    * 一段“代码逻辑”只有获得了“运行机会”才能被CPU执行
    

    内核级线程中可以运行任意一个有映射关系的用户级线程代码,只有两个内核级线程中正在运行的代码逻辑都阻塞时,这个进程才会阻塞

    小结

    在这里插入图片描述

    处理机的调度

    处理机调度概念、层次

    知识总览

    在这里插入图片描述

    调度的基本概念

    当有一堆任务要处理,但由于资源有限,这些事情没法同时处理。这就需要确定某种规则来决定处理这些任务的顺序,这就是“调度”研究的问题。

    在多道程序系统中,进程的数量往往是多于处理机的个数的,这样不可能同时并行地处理各个进程。处理机调度,就是从就绪队列中按照一定的算法选择一个进程并将处理机分配给它运行,以实现进程的并发执行。

    调度的三个层次

    高级调度

    由于内存空间有限,有时无法将用户提交的作业全部放入内存,因此就需要确定某种规则来决定将作业调入内存的顺序。

    高级调度(作业调度)。按一定的原则从外存上处于后备队列的作业中挑选一个(或多个)作业,给他们分配内存等必要资源,并建立相应的进程(建立PCB),以使它(们)获得竞争处理机的权利。

    高级调度是辅存(外存)与内存之间的调度。每个作业只调入一次,调出一次。作业调入时会建立相应的PCB,作业调出时才撤销PCB。高级调度主要是指调入的问题,因为只有调入的时机需要操作系统来确定,但调出的时机必然是作业运行结束才调出。

    中级调度

    引入了虚拟存储技术之后,可将暂时不能运行的进程调至外存等待。等它重新具备了运行条件且内存又稍有空闲时,再重新调入内存。

    这么做的目的是为了提高内存利用率和系统吞吐量。

    暂时调到外存等待的进程状态为挂起状态。值得注意的是,PCB并不会一起调到外存,而是会常驻内存。PCB中会记录进程数据在外存中的存放位置,进程状态等信息,操作系统通过内存中的PCB来保持对各个进程的监控、管理。被挂起的进程PCB会被放到的挂起队列中。

    中级调度(内存调度),就是要决定将哪个处于挂起状态的进程重新调入内存。

    一个进程可能会被多次调出、调入内存,因此中级调度发生的频率要比高级调度更高。

    补充知识:进程的挂起态与七状态模型

    暂时调到外存等待的进程状态为挂起状态(挂起态,suspend)
    挂起态又可以进一步细分为就绪挂起、阻塞挂起两种状态
    五状态模型 -----> 七状态模型

    在这里插入图片描述

    注意“挂起”和“阻塞”的区别,两种就绪挂起 状态都是暂时不能获得CPU的服务,但挂起态是将进程映像调到外存去了,而
    阻塞态下进程映像还在内存中。

    有的操作系统会把就绪挂起、阻塞挂起分为两个挂起队列,甚至会根据阻塞原因不同再把阻塞挂起进程进一步细分为阻塞挂起 多个队列。

    低级调度

    低级调度(进程调度),其主要任务是按照某种方法和策略从就绪队列中选取一个进程,将处理机分配给它。

    进程调度是操作系统中最基本的一种调度,在一般的操作系统中都必须配置进程调度。
    进程调度的频率很高,一般几十毫秒一次。

    在这里插入图片描述

    小结

    进程调度的时机切换与过程调度方式

    知识总览

    进程调度的时机

    进程调度(低级调度),就是按照某种算法从就绪队列中选择一个进程为其分配处理机。

    临界资源:一个时间段内只允许一个进程使用的资源。各进程需要互斥地访问临界资源。
    临界区:访问临界资源的那段代码。

    内核程序临界区一般是用来访问某种内核数据结构的,比如进程的就绪队列(由各就绪进程的PCB组成)

    有的系统中,只允许进程主动放弃处理机有的系统中,进程可以主动放弃处理机,当有更紧急的任务需要处理时,也会强行剥夺处理机(被动放弃)

    进程在普通临界区中是可以进行调度、切换的。

    在这里插入图片描述

    进程调度的方式

    非剥夺调度方式,又称非抢占方式。即,只允许进程主动放弃处理机。在运行过程中即便有更紧迫的任务到达,当前进程依然会继续使用处理机,直到该进程终止或主动要求进入阻塞态。

    # 实现简单,系统开销小但是无法及时处理紧急任务,适合于早期的批处理系统
    

    剥夺调度方式,又称抢占方式。当一个进程正在处理机上执行时,如果有一个更重要或更紧迫的进程需要使用处理机,则立即暂停正在执行的进程,将处理机分配给更重要紧迫的那个进程。

    # 可以优先处理更紧急的进程,也可实现让各进程按时间片轮流执行的功能(通过时钟中断)。适合于分时操作系统、实时操作系统
    

    进程的切换与过程

    “狭义的进程调度”与“进程切换”的区别:

    狭义的进程调度指的是从就绪队列中选中一个要运行的进程。(这个进程可以是刚刚被暂停执行的进程,也可能是另一个进程,后一种情况就需要进程切换)

    进程切换是指一个进程让出处理机,由另一个进程占用处理机的过程。

    过程

    广义的进程调度包含了选择一个进程和进程切换两个步骤。
    进程切换的过程主要完成了:

    1. 对原来运行进程各种数据的保存

    2. 对新的进程各种数据的恢复
      (如:程序计数器、程序状态字、各种数据寄存器等处理机现场信息,这些信息一般保存在进程控制块)

    注意:进程切换是有代价的,因此如果过于频繁的进行进程调度、切换,必然会使整个系统的效率降低,使系统大部分时间都花在了进程切换上,而真正用于执行进程的时间减少。

    小结

    在这里插入图片描述

    调度算法的评价指标

    知识总览

    在这里插入图片描述

    CPU利用率

    由于早期的CPU造价极其昂贵,因此人们会希望让CPU尽可能多地工作

    CPU利用率:指CPU “忙碌”的时间占总时间的比例。

    利 用 率 = 忙 碌 的 时 间 / 总 时 间 利用率 = 忙碌的时间 / 总时间 =/
    在这里插入图片描述

    系统吞吐量

    对于计算机来说,希望能用尽可能少的时间处理完尽可能多的作业

    系统吞吐量:单位时间内完成作业的数量
    系 统 吞 吐 量 = 总 共 完 成 了 多 少 道 作 业 / 总 共 花 了 多 少 时 间 系统吞吐量 = 总共完成了多少道作业 / 总共花了多少时间 =/
    Eg:某计算机系统处理完10道作业,共花费100秒,则系统吞吐量为?
    10/100 = 0.1 道 / 秒

    周转时间

    对于计算机的用户来说,他很关心自己的作业从提交到完成花了多少时间。

    周转时间,是指从作业被提交给系统开始,到作业完成为止的这段时间间隔。

    它包括四个部分:

    • 作业在外存后备队列上等待作业调度(高级调度)的时间、
    • 进程在就绪队列上等待进程调度(低级调度)的时间、
    • 进程在CPU上执行的时间、
    • 进程等待I/O操作完成的时间。

    后三项在一个作业的整个处理过程中,可能发生多次

    对于用户来说,更关心自己的单个作业的周转时间
    ( 作 业 ) 周 转 时 间 = 作 业 完 成 时 间 – 作 业 提 交 时 间 (作业)周转时间= 作业完成时间– 作业提交时间 =
    对于操作系统来说,更关心系统的整体表现, 因此更关心所有作业周转时间的平均值
    平 均 周 转 时 间 = 各 作 业 周 转 时 间 之 和 / 作 业 数 平均周转时间 = 各作业周转时间之和 / 作业数 =/
    在这里插入图片描述

    周转时间

    带权周转时间必然≥ 1
    带 权 周 转 时 间 = 作 业 周 转 时 间 / 作 业 实 际 运 行 的 时 间 = ( 作 业 完 成 时 间 – 作 业 提 交 时 间 ) / 作 业 实 际 运 行 的 时 间 带权周转时间 = 作业周转时间 / 作业实际运行的时间 = (作业完成时间– 作业提交时间) / 作业实际运行的时间 =/=()/

    平 均 带 权 周 转 时 间 = 各 作 业 带 权 周 转 时 间 之 和 / 作 业 数 平均带权周转时间=各作业带权周转时间之和/作业数 =/
    带权周转时间与周转时间都是越小越好

    等待时间

    计算机的用户希望自己的作业尽可能少的等待处理机

    等待时间,指进程 / 作业处于等待处理机状态时间之和,等待时间越长,用户满意度越低。

    对于进程来说,等待时间就是指进程建立后等待被服务的时间之和,在等待I/O完成的期间其实进程也是在被服务的,所以不计入等待时间。

    对于作业来说,不仅要考虑建立进程后的等待时间,还要加上作业在外存后备队列中等待的时间。

    一个作业总共需要被CPU服务多久,被I/O设备服务多久一般是确定不变的,因此调度算法其实只会影响作业 / 进程的等待时间。当然,与前面指标类似,也有“平均等待时间”来评价整体性能。

    响应时间

    对于计算机用户来说,会希望自己的提交的请求(比如通过键盘输入了一个调试命令)尽早地开始被系统服务、回应。

    响应时间,指从用户提交请求到首次产生响应所用的时间。

    小结

    在这里插入图片描述

    调度算法

    知识总览

    Tips:各种调度算法的学习思路

    1. 算法思想
    2. 算法规则
    3. 这种调度算法是用于作业调度还是进程调度?
    4. 抢占式?非抢占式?
    5. 优点和缺点
    6. 是否会导致饥饿

    饥饿:某进程 / 作业长期得不到服务.

    先来先服务(FCFS, First Come First Serve)

    按照作业 / 进程到达的先后顺序进行服务

    用于作业 / 进程调度: 用于作业调度时,考虑的是哪个作业先到达后备队列;用于进程调度时,考虑的是哪个进程先到达就绪队列

    非抢占式的算法

    优点:公平、算法实现简单
    缺点:排在长作业(进程)后面的短作业需要等待很长时间,带权周转时间很大,对短作业来说用户体验不好。即,FCFS算法对长作业有利,对短作业不利(Eg :排队买奶茶…)

    不会产生饥饿现象

    在这里插入图片描述

    短作业优先(SJF, Shortest Job First)

    算法思想:追求最少的平均等待时间,最少的平均周转时间、最少的平均平均带权周转时间

    算法规则: 最短的作业 / 进程优先得到服务(所谓“最短”,是指要求服务时间最短)

    即可用于作业调度,也可用于进程调度。用于进程调度时称为“短进程优先(SPF, Shortest Process First)算法”

    SJF和SPF是非抢占式的算法。但是也有抢占式的版本——最短剩余时间优先算法(SRTN, Shortest Remaining Time Next)

    1. 这种调度算法是用于作业调度还是进程调度?
    2. 抢占式?非抢占式?
    3. 优点和缺点
    4. 是否会导致饥饿

    饥饿:某进程 / 作业长期得不到服务.

    短作业优先(SJF, Shortest Job First)

    算法思想:追求最少的平均等待时间,最少的平均周转时间、最少的平均平均带权周转时间

    算法规则: 最短的作业 / 进程优先得到服务(所谓“最短”,是指要求服务时间最短)

    即可用于作业调度,也可用于进程调度。用于进程调度时称为“短进程优先(SPF, Shortest Process First)算法”

    SJF和SPF是非抢占式的算法。但是也有抢占式的版本——最短剩余时间优先算法(SRTN, Shortest Remaining Time Next)

    展开全文
  • 进程的概念与进程控制

    进程基本概念

    程序的顺序执行及其特征

    程序的顺序执行
    仅当前一操作(程序段)执行完后,才能执行后继操作。
    特征

    • 顺序性
    • 封闭性
    • 可再现性

    程序的并发执行及其特征

    多个程序的并发执行
    在一定时间内物理机器上有两个或两个以上的程序同处于开始运行但尚未结束的状态,并且次序不是事先确定的。宏观上同时处于运行状态微观上各程序交替地间断运行。
    特征

    • 在并发环境下程序的执行是间断性的
      执行——停——执行
    • 失去封闭性
      并发程序共享系统中的资源,资源状态将由多个程序改变,某程序执行过程和结果会受其它程序的影响。
    • 程序结果的不可再现性
      由于失去封闭性,并发程序执行的结果不可再现,与其执行的相对速度有关,是不确定的。
    • 程序与CPU执行的活动之间不再一一对应
      程序与CPU执行的活动,这是两个不同的概念;程序是完成某一特定功能的指令序列,是静态的概念;而CPU执行的活动是一个动态概念,它是程序的执行过程。程序在顺序执行(即单道运行)时,程序与CPU执行的活动是一一对应的,而在程序并发执行(即多道程序)时,这种关系不再存在。

    进程的特征与状态

    较为典型的进程定义有

    • 进程是程序的一次执行。
    • 进程是一个程序及其数据在处理机上顺序执行时所发生的活动。
    • 进程是程序在一个数据集合上运行的过程,它是系统进行资源分配和调度的一个独立单位。

    进程的基本特征

    • 结构性
      由程序+数据+进程控制块组成了进程实体,称之为进程映像。进程控制块是进程存在的标志。
    • 动态性
      进程是进程实体的执行过程,它由创建而产生,由调度而执行,因某事件而暂停,由撤销而消亡。在生命周期内,进程在三种基本状态之间动态转换
    • 并发性
      多个进程同时存于内存中,一起向前推进,并发执行
    • 独立性
      进程是独立获得资源和独立调度的基本单位
    • 异步性
      各进程都各自独立的不可预知的速度向前推进

    进程的基本状态及其转换

    进程的三种基本状态

    • 运行态:执行态
      进程占有CPU,并在CPU上运行
    • 就绪态
      进程已经具备运行条件,但由于CPU忙而暂时不能运行的状态(当调度给其CPU时,立即可以运行)。
    • 阻塞态:等待态、封锁态。冻结态、睡眠态
      进程因等待某种事件的发生而暂时不能运行的状态。(即使CPU空闲,该进程也不可运行)。

    进程生命周期内处于且仅处于三种基本状态之一,不同的系统设置的进程态度数目不同。
    进程状态转换

    • 就绪→运行
      调度:调度程序选择一个新的进程运行
    • 运行→就绪
      超时:运行进程用完时间片被中断,在抢占调度方式中,因为一高优先级进程进入就绪状态
    • 运行→阻塞
      I\O请求:当进程发生I\O请求或等待某事件时
    • 阻塞→就绪
      I\O完成:当I\O完成或所等待的事件发生时

    在这里插入图片描述
    进程的挂起状态
    引入原因:由于终端用户、父进程及操作系统的需要,要将某进程静止下来不接受调度,增加了静止阻塞(阻塞挂起)和静止就绪(就绪挂起)态,原阻塞和就绪改称为活动阻(Blockeda)和活动就绪(Readya)态。

    • 运行或活动就绪→静止就绪,活动阻塞→静止阻塞
      通过挂起原话
    • 静止就绪→活动就绪,静止阻塞→活动阻塞
      通过激活原语
    • 静止阻塞→静止就绪:当等待的事件发生时

    在这里插入图片描述

    进程控制块

    进程控制块的作用
    系统为管理进程设置一个专门的数据结构一进程控制块(Process Control Block),用它来记录进程的外部特征,描述进程的运动变化过程(从结构的观点上看,程序与进程的区别就在于有没有PCB)、进程与PCB一一对应,在进程的整个生命期内,PCB随进程的创建而产生随进程的终止而消失,系统利用PCB来控制和管理进程,系统根据PCB感知进程的存在,所以PCB是进程存在的唯一标志。存放控制进程所需的数据(进程属性)。
    PCB中的信息

    • 进程的标识信息
    • 处理器状态信息(现场信息)
    • 进程调度信息
    • 进程控制信息

    1.进程标识符(在PCB中)
    进程标识符用于唯一地标识一个进程

    • 外部标识符
      由创建者提供,由字符、数字组成
    • 内部标识符
      为了方便系统而设置,OS中,每个进程有唯一的标识符(PID)

    2.处理器状态信息(现场信息)
    进程走走停停必须保存处理器的状态信息即处理器现状,它由处理器寄存器内容组成。

    • 通用寄存器(8—32 个,RISC结构中超过100个)
    • 指令计数器(下一条指令的地址)
    • 状态寄存器(程序状态字PSW,如:EFLAGS寄存器)
    • 用户栈指针(过程和系统调用参数及地址)

    3.进程调度信息

    • 进程状态(如:运行、就绪、阻塞…)
    • 进程优先级
    • 该进程在等待的事件(阻塞原因)
    • 调度所需其他信息(如:等待总时间,执行总时间)

    4.进程控制信息

    • 程序和数据的地址
      程序和数据所在的内存(段/页表指针)或外存地址
    • 进程间同步和通信机制
      需要的消息队列指针和信号量等
    • 所需的和已分配到的资源清单及使用情况
      出CPU外的资源:文件,I/O设备…它们的使用史
    • 数据结构信息
      进程可能需要有指向其他PCB的指针,父-子进程关系及其它结构

    进程块的组织方式
    PCB表:系统把所有PCB组织在一起,并把它们放在内存的固定区域,就构成了PCB表,PCB表的大小决定了系统中最多可同时存在的进程个数,称为系统的并发度
    :多道程序中的道数与系统并发度不同
    PCB表组织方式

    • 链接方式
      在这里插入图片描述
    • 索引方式
      在这里插入图片描述
      进程队列
      在这里插入图片描述

    进程控制

    进程的创建

    进程何时创建
    引起创建进程的事件:
    用户登录作业调度提供服务应用请求
    进程创建过程
    一旦发现了要求创建新进程的事件,OS便调用创建原语,按以下过程创建新进程。

    • 分配一个唯一的进程标识符,索取一个空白的PCB
    • 为新进程的程序和数据分配内存空间
    • 初始化进程控制块初始化标识符信息(填入)、处理机的状态信息(指令指针,栈指针)和控制信息(状态,优先级…)
    • 设置相应的链接,如:把新进程加到就绪队列的链表中

    进程的终止(撤销)

    进程何时终止

    • 正常结束
      批处理系统中,进程已运行完成遇到Halt指令分时系统中,用户退出登录
    • 异常结束
      本进程发生出错和故障事件
      存储区越界、保护性错(如:写只读文件)、特权指令错、非法指令(如:程序错转到数据区)、算术运算错、运行超时、等待超过时、I/O失败、
    • 外界干预
      操作系统干预、父进程请求、父进程终止.

    进程的终止过程
    一旦发生终止进程的事件,OS便调用撤消原语,按以下过程终止该进程。

    • 从PCB中读取进程的状态
    • 若进程处于执行态,应立即终止该进程的执行,并置调度标志为真(以便该进程终止后系统重新进行调度,将处理机分配给新选择的进程)
    • 若有子孙进程则将它们全部终止,以防它们失控
    • 将该进程所占有的全部资源还给父进程或系统
    • 将该进程的PCB从所在队列中移出

    进程的阻塞与唤醒

    引起进程阻塞和唤醒的事件

    • 请求系统服务:服务未满足.
    • 启动某种操作:典型I/O操作
    • 新数据尚未到达:
    • 无新工作可做:等待

    进程阻塞过程
    正在执行的进程,当发现上述某事件时,由于无法继续执行,于是进程便通过调用阻塞原语block把自己阻塞。可见,进程的阻塞是进程自身的一种主动行为。进入block过程后,由于此时该进程还处于执行状态,所以应先立即停止执行,把进程控制块中的现行状态由“执行”改为阻塞,并将PCB插入阻塞队列。如果系统中设置了因不同事件而阻塞的多个阻塞队列,则应将本进程插入到具有相同事件的阻塞(等待队列。最后,转调度程序进行重新调度,将处理机分配给另一就绪进程,并进行切换,亦即,保留被阻塞进程的处理机状态(在PCB中),再按新进程的PCB中的处理机状态设置CPU的环境。.
    进程的唤醒过程
    当被阻塞进程所期待的事件出现时,如I/O完成或其所期待的数据已经到达,则由有关进程(比如,用脘并释放了该I/O设备的进程)调用唤醒原语wakeup(),将等待该事件的进程唤醒。唤醒原语执行的过程是:首先把被阻塞的进程从等待该事件的阻塞队列中移出,将其PCB中的现行状态由阻塞改为就绪,然后再将该PCB插入到就绪队列中。

    进程的挂起与激活

    进程的挂起
    当出现了引起进程挂起的事件时,比如,用户进程请求将自己挂起,或父进程请求将自己的某个子进程挂起,系统将利用挂起原语suspend()将指定进程或处于阻塞状态的进程挂起。挂起原语的执行过程是:首先检查被挂起进程的状态,若处于活动就绪状态,便将其改为静止就绪;对于活动阻塞状态的进程,则将之改为静止阻塞。为了方便用户或父进程考查该进程的运行情况而把该进程的PCB复制到某指定的内存区域。最后,若被挂起的进程正在执行,则转向调度程序重新调度。
    进程的激活过程
    当发生激活进程的事件时,例如,父进程或用户进程请求激活指定进程,若该进程驻留在外存而内存中已有足够的空间时,则可将在外存上处于静止就绪状态的进程换入内存这时,系统将利用激活原语active()将指定进程激活。激活原语先将进程从外存调入内存,检查该进程的现行状态,若是静止就绪,便将之改为活动就绪;若为静止阻塞便将之改为活动阻塞。假如采用的是抢占调度策略,则每当有新进程进入就绪队列时,应检查是否要进行重新调度,即由调度程序将被激活进程与当前进程进行优先级的比较,如果被激.活进程的优先级更低,就不必重新调度;否则,立即剥夺当前进程的运行,把处理机分配给刚被激活的进程。

    总结

    • 并发执行新特征:
      间断性失去封闭性和可再现性相互制约性.
    • 进程的基本特征:
      动态性并发性独立性异步性和结构性
    • 进程定义:
      进程是可以并发执行的程序在某个数据集合上的运行过程,是系统进行资源分配和调度的独立位。
    • 进程控制块PCB :
      系统为管理进程设置的专用数据结构,存放进程的特征和变化过程及控制进程所需的所有数据,是进
      程控制和调度的依据和操作对象。PCB与进程生命期相同一一对应,是进程存在的唯一标志。
    • PCB中的内容:
      进程标识符处理器状态调度信息控制信息
    • 进程的三种基本状态:
      运行态就绪态阻塞态.
    • 进程的状态转换:
      调度:就绪→运行
      超时:运行→就绪
      I/O请求/等待事件:运行→阻塞
      I/O完成/等待事件发生:阻塞→就绪
      挂起原语:活动→静止
      激活原语:静止→活动
    展开全文
  • Linux进程管理、服务管理、软件包管理(rpm、yum)详细讲解。

    目录​​​​​​​

    一、进程管理

    1. 查看进程信息

    2. 查看父进程信息

    3. 终止进程

    4. 查看进程树

    5. 动态监控进程

    二、服务管理

    1. 服务管理

    2. 服务的运行级别

    3. 服务管理指令 systemctl(CentOS 7.0之后)

    4. 打开/关闭指定端口

    三、软件包管理(rpm、yum)

    1. rpm 包的管理

    2. yum 包的管理


    一、进程管理

            在 Linux 操作系统中,每一个执行的程序都是被称之为进程,且每个进程都有它专属的进程号 pid;每个进程可能都以前台后台两种方式存在,前台进程就是用户直接可在屏幕上操作的部分,与用户直接交互;后台进程则无法在屏幕看到,只在后台运行(一般系统服务都是以后台进程的方式存在,常驻于 系统,只有关机才会结束)

    程序 是静态的实体;
    进程 则是动态的实体,可以理解为运行着的程序;

    1. 查看进程信息

    使用指令 ps 可以查看当前系统正在运行的进程以及它们执行的状态;

    • ps -a  //显示当前终端所有的进程信息
    • ps -u  //以用户的格式显示进程信息
    • ps -x  //显示后台进程运行的参数
    • ps -aux | more  //分页查看所有进程信息

    如下分页查看所有进程信息:

    各字段含义如下:

    2. 查看父进程信息

    除进程本身外,进程也可以创建多个子进程,进而就有了父进程子进程的概念;

    查看父进程的信息需要先知道父进程的 pid,此时需要使用指令 ps -ef 以全格式显示当前的所有进程。例如我们查看进程 sshd(远程登录) 的父进程信息(结果只需看第一条即可);

    可以看到,进程 sshd 的 id 为 1478,它的父进程 id 为 1;此时再全格式查看进程信息就可以找到 id 为 1 的进程是哪个了;

    以全格式查看进程信息时新增了 PPID 字段,代表此进程的父进程 pid;PPID 为 0 表示该进程没有父进程。

    3. 终止进程

    需要停止某进程时,可以使用指令 kill 进程号 或者 killall 进程名 分别通过进程号或进程名终止该进程;需要注意的是,如果一个进程下有子进程,该进程被终止后它的所有子进程也将被终止。

    终止进程指令常用选项:

    • -9  //强制进程立即停止

    4. 查看进程树

    查看进程树使用指令 pstree,相较于使用 ps 指令它可以更加直观;

    • pstree -p  //显示进程的pid
    • pstree -u  //显示进程的所属用户

    5. 动态监控进程

    动态监控进程使用指令 top,功能与 ps 指令相似,区别在于 top 是动态的监控进程,可以查看进程的更新过程。

    • top -d 秒数  //指定top命令每隔几秒更新一次当前进程的执行情况(默认3s)
    • top -i  //top指令不再显示任何僵死或者闲置的进程
    • top -p  //通过进程号pid指定监控某个进程执行情况

    在使用 top 指令动态查看进程的过程中,我们也可以进行一些交互操作:

    • 按下 “P” 使进程按照  CPU 的使用率进行排序(默认)
    • 按下 “M” 按照内存占用率排序
    • 按下 “N” 按照 pid 进行排序
    • 按下 “u” 再输入用户名,监控指定用户的进程
    • 按下 “k” 再输入进程号,终止指定的进程
    • 按下 “q” 退出 top 指令

    二、服务管理

            服务管理中的服务本质上就是一个后台的进程。服务运行在后台,监听某个端口等待某个程序的请求,如 sshd、mysqld、防火墙 等都属于服务,服务又被称为守护进程。

    1. 服务管理

    服务管理使用的指令为 service 服务名 选项(注意在 CentOS 7.0 之后不再使用 service 指令,由 systemctl 指令代替)

    常用选项有:

    • start  //启动服务
    • stop  //关闭服务
    • restart  //重启
    • reload  //重载
    • status  //状态

    当然,service 指令依旧可以管理若干服务,具体存储在 /etc/init.d 目录下。如下是 7.0 版本之后 services 指令所管理的服务:

    使用指令 setup 可以查看 Linux 操作系统的所有服务;如下为所有系统服务,前面带 [*] 的代表此服务会随着操作系统的启动而自动启动,我们可以使用空格键来选择它是否选中。

    2. 服务的运行级别

    之前已经有介绍,Linux 操作系统中一共有七种运行级别;

    • 0 - 系统停机状态,系统默认运行级别不能设置为0,否则无法正常启动(基本不用)
    • 1 - 单用户工作状态,常用于系统维护,没有远程登陆功能(基本不用)
    • 2 - 多用户工作状态,不支持网络服务
    • 3 - 多用户状态,无界面,登陆后进入控制台命令行模式(最常用)
    • 4 - 系统未使用
    • 5 - 图形界面模式(常用)
    • 6 - 系统正常关闭并重启,默认运行级别不能设为6,否则不能正常启动

    通过指令 chkconfig 可以为服务的各个运行级别设置自启动或关闭自启动(注意该命令在 CentO S 7.0 之后也不再使用,由 systemctl 代替)

    • chkconfig --list  //查看 chkconfig 命令管理的服务
    • chkconfig --level 运行级别 服务名 on/off  //设置某个服务在某个运行级别为自启动或者关闭自启动

    举例:关闭 network 服务在运行级别 3 的自启动服务,再使用 --list 指令可以看到,network 服务的自启动功能已关闭。

    打开自启动功能只需把 off 改为 on 即可;

    使用 chkconfig 指令设置服务的自启动功能后,需要重启系统才能生效。

    3. 服务管理指令 systemctl(CentOS 7.0之后)

    基本语法:systemctl 选项 服务名

    • 常用选项与 service 相同
    • systemctl list-unit-files  //查看当前各个服务的自启动状态,可使用管道过滤
    • systemctl enable 服务名  //设置服务开机自启动
    • systemctl disable 服务名  //关闭服务开机自启动
    • systemctl is-enabled 服务名  //查看某服务是否为自启动状态

    systemctl 指令设置的自启动服务默认在运行级别 3 和 5 。

    systemctl 指令所管理的服务存储于 /usr/lib/systemd/system 目录下;

    4. 打开/关闭指定端口

    打开或关闭指定端口主要是针对防火墙服务。在平常的工作中,防 火墙都是打开状态,但是打开防火墙服务就会造成一个问题,那就是外部请求数据包无法再与服务器所监听的端口进行通讯。这时候我们就需要打开某个指定的端口。打开/关闭指定端口使用指令 firewall

    • firewall-cmd --permanent --add-port=端口号/协议  //打开端口
    • firewall-cmd --permanent --remove-port=端口号/协议  //关闭端口
    • firewall-cmd --reload  //重新载入(必须重新载入新设置才会生效)
    • firewall-cmd --query-port=端口/协议  //查询端口是否开放

    查询端口和协议使用指令 netstat -anp

    三、软件包管理(rpm、yum)

    1. rpm 包的管理

    rpm(RedHat Package Manage)是用于网络下载包的打包及安装工具,包含于某些 Linux 分发版本中,它会生成以 .rpm 为扩展名的文件。

    查询已安装的 rpm 包列表使用指令 rpm -qa,必要时可以使用管道进行过滤。

    • rpm -qa  //查询所安装的所有软件包
    • rpm -q 软件包名  //查询某软件包是否安装
    • rpm -qi 软件包名  //查询软件包信息
    • rpm -ql 软件包名  //查询软件包中的文件
    • rpm -qf 文件全路径名  //查询文件所属的软件包

    如下使用 rpm 指令查看系统是否安装了 Firefox;

    卸载 rpm 包使用指令 rpm -e 包名称

    (​​​​​​删除包的时候需要注意,如果有其他软件依赖于所要删除的包,卸载会产生错误信息,如果想要强制删除可以增加 --nodeps 选项如: rpm -e --nodeps 包名,但不建议此做法)

    安装 rpm 包使用指令 rpm -ivh 包全路径名称(i 安装,v 提示信息,h 进度条)。

    2. yum 包的管理

    yum 是 shell 前端软件包管理器,基于 rpm 包管理,能够从指定的服务器自动下载 RPM 包并且安装,可以自动处理依赖性关系,并且一次安装所有依赖的软件包,无须繁琐地一次次下载、安装。yum 基本指令如下:

    • yum list  //查询yum服务器上可以安装的软件和已安装的软件
    • yum install 包名  //安装指定的软件包
    展开全文
  • Linux系统管理----centos7系统进程管理

    万次阅读 2022-03-06 19:22:27
    一、进程概念 1.进程组成部分: 2.僵尸进程: 3.线程: 4.上下文切换: 5.中断处理: 6.进程的属性 二、ps查看进程工具 1.-aux弹出消息及详解 2、linux进程有5种基本状态 三、free 查看内存使用情况 1.弹...
  • Linux之进程管理

    千次阅读 2022-04-22 10:50:20
    头歌educatorLinux之进程管理
  • Linux——进程管理 1.实验目的 (1)加深对进程概念的理解,明确进程和程序的区别。 (2)进一步认识并发执行的实质。 (3)分析进程争用资源的现象,学习解决进程互斥的方法。 2.实验预备内容 (1)复习课本关于...
  • Linux进程管理(一)进程数据结构

    千次阅读 2019-10-27 16:59:46
    Linux进程管理(一)进程数据结构 文章目录Linux进程管理(一)进程数据结构双向链表任务ID信号处理进程状态进程调度运行统计信息进程亲缘关系内存管理文件与文件系统进程内核栈栈结构current宏 Linux内核中使用 ...
  • 计算机操作系统实验之模拟进程管理(C语言)

    万次阅读 多人点赞 2019-10-14 00:09:07
    利用C语言模拟实现操作系统中的进程管理
  • 处理器管理与进程管理

    千次阅读 2019-04-25 21:25:29
    用图文描述组成进程的要素,并说明其作用。 一、进程概念 引子 :程序运行在并发环境中的问题 (1)运行过程不确定 (2)结果不可再现1.进程定义 进程是程序在某个数据集合上的一次运行活动。数据集合是指软...
  • 操作系统——进程管理的功能

    千次阅读 2020-08-16 21:47:29
    进程控制是进程管理中的最基本的功能,主要包括创建新进程、终止已完成的进程、将因发生异常情况而无法继续运行的进程置于阻塞状态、负责进程运行中的状态转换功能。 简单来说:进程控制就是要实现进程状态的转换 2....
  • 广州大学2020操作系统实验一:进程管理与进程通信

    千次阅读 多人点赞 2020-07-24 17:15:57
    实验一 进程管理与进程通信 一、实验目的 1、掌握进程的概念,明确进程的含义。 2、认识并了解进程并发执行的实质,进程的阻塞与唤醒,终止与退出的过程。 3、熟悉进程的睡眠、同步、撤消等进程控制方法。 4、分析...
  • 简易网页版进程管理器(支持手机管理电脑进程)

    万次阅读 多人点赞 2021-07-10 01:04:49
    大家好,我是小小明,今天要带大家做一款简易的网页版进程管理器,最终效果如下: 目标只要求能查看内存使用何cpu使用率即可。 基础模块技术测试 读取进程信息 首先,我们可以使用psutil读取服务端的进程使用情况...
  • 进程管理(超详细篇)

    千次阅读 2020-11-24 21:17:54
    进程管理process 什么是进程? 进程:是程序运行的过程,动态,有生命周期及运行状态 进程是已启动的可执行程序的运行实例,进程分为四个部分: 1.已分配内存的地址空间 2.安全属性,包括所有权凭据和特权 3.程序...
  • 计算机操作系统进程管理总结

    万次阅读 多人点赞 2018-06-07 11:57:03
    计算操作系统进程管理 一、进程与线程 1.1、进程 进程是资源分配的基本单位。 进程控制块PCB(Process Control Block)描述的是进程的基本信息以及进程的运行状态,我们说的创建及撤销进程都是对进程控制块...
  • 操作系统实验一 进程管理

    万次阅读 多人点赞 2019-05-18 14:59:09
    实验一 进程管理 1.目的和要求 通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。 2.实验内容 用C语言编程模拟进程管理,...
  • 操作系统实验三:进程管理

    千次阅读 2021-01-21 18:23:54
    实验三 进程管理 一、实验要求 (1)掌握操作系统中进程的基本概念; (2)掌握 Linux操作系统进程管理基本方法; (3)了解进程并发运行的过程。 二、实验内容 (1)验证实验: ① 启动vi编辑器,并将其调入后台
  • 电脑中如何打开进程管理器?

    千次阅读 2021-11-10 15:54:24
    首先按快捷键“ctrl+alt+del”。 在弹出么窗口中打开“任务管理器”。 进入任务管理器界面后,点击左上角的“进程”。 右击菜单栏,点击“任务管理器”,然后可以查看进程
  • 操作系统课程设计(进程管理

    热门讨论 2010-04-18 16:20:55
    操作系统课程设计 进程管理操作系统课程设计 进程管理操作系统课程设计 进程管理操作系统课程设计 进程管理操作系统课程设计 进程管理操作系统课程设计 进程管理
  • 什么是进程同步 进程互斥的原则 进程互斥的软件实现方法 1、单标志法 2、双标志先检查法 3、双标志后检查法 4、Peterson 算法 进程互斥的硬件实现方法 1、中断屏蔽方法 2、TestAndSetLock 指令 TSL和中断屏蔽的区别 ...
  • 操作系统实验——进程管理与进程通信

    千次阅读 多人点赞 2020-01-05 10:22:10
    实验一 进程管理与进程通信 一、实验目的 1、掌握进程的概念,明确进程的含义。 2、认识并了解进程并发执行的实质,进程的阻塞与唤醒,终止与退出的过程。 3、熟悉进程的睡眠、同步、撤消等进程控制方法。 4、分析...
  • Linux 进程管理

    万次阅读 多人点赞 2019-05-09 11:13:06
    (1)在LINUX中,每个执行的程序(代码)都称为一个进程。每一个进程都分配一 个ID号。 (2) 每一个进程,都会对应一个父进程,而这个父进程可以复制多个子进程。 (3) 每个进程都可能以两种方式存在的。前台...
  • 服务与进程管理1.掌握Inittab文件的更改2.能开始、重启、停止、查看NFS进程,分别测试3.掌握自动启动进程的使用,如NETWORK进程在16级别开启4.用CAT命令开启一个进程,并用另外一个窗口结束进程5.用at命令进行进程的...
  • Qt:Windows编程—Qt实现进程管理

    千次阅读 2019-01-20 23:04:44
    利用相关的API使用Qt写界面实现了一个简单的进程管理。主要用到 进程的创建、进程的枚举、线程的枚举、DLL的枚举、进程提权等功能。相关API的介绍可以看 C/C++:Windows编程—创建进程、终止进程、枚举进程、枚举...
  • Linux中的进程管理总结

    千次阅读 多人点赞 2020-05-28 15:00:41
    本文的主要内容是有关于Linux进程管理(查看,终止,监控) 1. 进程的进本介绍 在linux中,每一个执行的程序和指令都称为一个进程.每一个进程都有一个独立的进程号 每一个进程,都会有一个对应的父进程.而这个父...
  • 操作系统进程管理-同步和互斥 在看了操作系统关于进程管理中的同步互斥机制章节之后,甚是困惑,今天通过视频、网上博客资料学习之后,整理一下相关知识点。 进程管理 一、进程互斥 由于进程具有独立性和异步...
  • 操作系统——实验二 进程管理

    千次阅读 2020-11-30 17:17:29
    (1)阅读Linux的sched.h源文件,加深对进程管理概念的理解。 (2)阅读Linux的fork.c源文件,分析进程的创建过程。 3、实验内容 (1)进程的创建 编写一段源程序,使系统调用fork()创建两个子进程,当此程序运行时...
  • Python supervisor 强大的进程管理工具

    千次阅读 2019-04-22 19:42:51
    进程变为后台进程后,同一个终端就会释放了,你可以在其中干别的事情,而不会干扰到你跑的服务。后台进程一般来说不能捕捉输入,服务的输出依然可以选择在终端输出。 同样的道理,理解前台...
  • 操作系统概论【二】- - 进程管理

    万次阅读 多人点赞 2020-08-16 20:53:24
    文章目录第二章、进程管理一、进程的描述1. 为什么要引入进程的概念?a.程序的顺序执行b.程序的并发执行c.进程的概念2. 进程的定义3. 进程的特征4. 进程与程序的比较5.进程控制块6. 进程的状态7. 进程的组织三种组织...
  • 操作系统基本原理---进程管理

    千次阅读 2018-08-02 21:34:45
    因此,处理机管理也被称为进程管理。处理机管理的功能就是组织和协调用户对处理机的争夺使用,把处理机分配给进程,对进程进行管理和控制,最大限度也发挥处理机的作用。   1.进程的概念用静态的观点看,操作...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,225,705
精华内容 490,282
关键字:

进程管理

友情链接: main_Stepper Motor_MDO.rar