精华内容
下载资源
问答
  • 操作系统:进程的三种状态

    千次阅读 2019-01-17 14:52:55
    1. 就绪状态:进程获得了除了CPU之外的所有的必要资源,只要获得CPU就可以立即执行,此时的进程处于就绪态。 2. 运行状态:进程已经获得CPU,正在运行,在多处理其系统中,会有多个进程同时处于运行状态。 3. ...

    进程的三种状态

    1.   就绪状态:进程获得了除了CPU之外的所有的必要资源,只要获得CPU就可以立即执行,此时的进程处于就绪态。

    2.   运行状态:进程已经获得CPU,正在运行,在多处理其系统中,会有多个进程同时处于运行状态。

    3.   阻塞状态:处于执行状态的进程由于发生某些事件而暂时无法继续执行,放弃处理机而处于暂停状态,此时进程就处于阻塞(执行受到阻塞)状态。

    进程的三种状态之间有4种可能的转换关系:


     


    2、状态:


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


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


        3:阻塞状态   正在执行的进程,由于等待某个事件发生而无法执行时,便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种,例如,等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。


    3、三种基本状态转换:

       

     (1) 就绪→执行
    处于就绪状态的进程,当进程调度程序为之分配了处理机后,该进程便由就绪状态转变成执行状态。

    (2) 执行→就绪
    处于执行状态的进程在其执行过程中,因分配给它的一个时间片已用完而不得不让出处理机,于是进程从执行状态转变成就绪状态。(一旦再次分配到时间片就可以立即执行)

    (3) 执行→阻塞
    正在执行的进程因等待某种事件发生而无法继续执行时,便从执行状态变成阻塞状态。

    (4) 阻塞→就绪
    处于阻塞状态的进程,若其等待的事件已经发生,于是进程由阻塞状态转变为就绪状态。

    展开全文
  • 就绪状态进程等待什么?

    千次阅读 2019-07-05 15:12:31
    参考回答: 被调度使用cpu的运行权

    参考回答:

    被调度使用cpu的运行权
    
    展开全文
  • 进程的基本状态及转换和阻塞及挂起的理解

    万次阅读 多人点赞 2018-06-24 16:12:26
    执行状态一个进程在处理机上运行,则称该进程处于运行状态。 阻塞状态:一个进程正在等待某一事件发生(例如请求I/O而等待I/O完成等)而暂时仃止运行,这时即使把处理机分配给进程也无法运行,故称该进程...

    概念描述:

    • 就绪状态 :一个进程获得了除处理机外的一切所需资源,一旦得到处理机即可运行,则称此进程处于就绪状态。
    • 执行状态:当一个进程在处理机上运行时,则称该进程处于运行状态。
    • 阻塞状态:一个进程正在等待某一事件发生(例如请求I/O而等待I/O完成等)而暂时仃止运行,这时即使把处理机分配给进程也无法运行,故称该进程处于阻塞状态。
    • 挂起状态:由于IO的速度慢于CPU的运算速度,经常出现CPU等待I/O的情况。这时OS需要将主存中的进程对换至外存。在进程行为模式中需要增加一个新的挂起(suspend)状态。当内存中所有进程阻塞时,OS可将一进程置为挂起态并交换到外存,再调入另一个进程执行。
    • 新建状态:进程刚创建,但还不能运行,OS还没有把它加到可执行进程组中,通常是还没有加载到主存中的新进程。
    • 退出状态:OS从可执行进程组中释放出的进程,或者是因为它自身停止了,或者是因为某种原因被取消。进程不在适合执行,但与作业相关的表和其它信息临时被OS保留起来,为其他程序提供所需信息。
    • 活跃就绪:指进程在主存并旦可被调度的状态。
    • 静止就绪:指进程被对换到辅存时的就绪状态,是不能被直接调度的状态,只有当主存中没有活跃就绪态进程,或者是挂起态进程具有更高的优先级,系统将把挂起就绪态进程调回主存并转换为活跃就绪。
    • 活跃阻塞:指进程在主存中。一旦等待的事件产生,便进入活跃就绪状态。
    • 静止阻塞:指进程对换到辅存时的阻塞状态。一旦等待的事件产生,便进入静止就绪状态。

    进程转换状态图

    • 三种基本状态转换图:
    就绪 执行 阻塞 进程调度 时间片用完 I/O请求 I/O完成 就绪 执行 阻塞

    这里写图片描述

    • 五种基本状态转换图(单挂起):
    新建 就绪 执行 阻塞 挂起 退出 允许进入 分派 时间片用完(超时) 事件等待(I/O请求) 事件发生(I/O完成) 挂起 激活 释放 新建 就绪 执行 阻塞 挂起 退出

    这里写图片描述

    • 五种基本状态转换图(双挂起):
    新建 活跃就绪 静止就绪 执行 活跃阻塞 静止阻塞 退出 允许进入 允许进入 挂起 激活 分派 时间片用完(超时) 事件等待(I/O请求) 挂起 事件发生(I/O完成) 挂起 激活 事件发生(I/O完成) 释放 新建 活跃就绪 静止就绪 执行 活跃阻塞 静止阻塞 退出

    这里写图片描述

    阻塞及挂起的理解

    1. 挂起是一种主动行为,是把一个进程从内存转到外存,而阻塞则是一种被动行为(并不绝对,看个人理解),是在等待事件或资源时任务的表现。对于挂起,其进程所有资源都转入外存;而阻塞,其进程所有资源依然保存在内存中
    2. 对应挂起的行为是激活,即当没有活动就绪进程时或静止就绪队列里面有进程优先级高于活动就绪里面所有进程,还有就是当一个进程释放足够内存时,系统会把一个高优先级阻塞激活。而阻塞却没有对应的主动行为来解除,需要其他进程或系统唤醒。
    3. 一个比喻:只有一个锅,当食材已经准备充分的菜就可以下锅,这就是执行态;而其他准备好的菜就顺序放在一旁,等待下锅,这就是就绪态;还有的菜准备还不是很充分,例如该切片的菜还没有切片,还有一些佐料还没有从冰箱里拿出,这就是I/O操作等待,类似阻塞态;而还有一种情况就是厨房的面积太小了,桌子上放不下那么多的准备下锅的菜,于是先将那些还没有准备好的菜放入冰箱,如果还是放不了那么多菜,就把那些已经准备好的但没有下锅的菜放入冰箱,以免变质,这就是挂起态;当桌子上有位置了,就把菜从冰箱拿出来,这便是激活操作。做好的菜就可以端出厨房,这便是退出态。(PS:这里我假设冰箱空间很大,也存在那种炒到一半的菜放到一边的情况,即从执行态到就绪态或阻塞态的情况,这种情况可以类似川菜中先将肉处理一下(去腥等等),然后又从锅里捞出来,用豆瓣和其他佐料来进行腌制(这里如果佐料没有在桌子上就类似进入阻塞态,而如果有就相当于进入就绪态,但是锅里已经被占用了,需要等待一会儿)至于优先级的高低,也可类比有些菜是为了其他菜做铺垫(举个例子:在川菜里面,回锅肉和炒白菜,一般家庭会优先做回锅肉,因为当做回锅肉时,会炒出许多猪油,而这些有可以用来炒白菜,这样的炒白菜不仅好吃,而且也节约了许多油。))
    展开全文
  • 一个进程终止了,我们需要知道进程退出状态,我们需要通过进程结束的退出码来识别。 进程正常结束: 1.从main()函数返回 2.调用exit()函数 3.调用_exit()//系统调用 我们可以用(echo $?)查看上一次...

    一、进程退出

    当一个进程终止了,我们需要知道进程退出时的状态,我们需要通过进程结束时的退出码来识别。

    进程正常结束时:

    1.从main()函数返回

    2.调用exit()函数

    3.调用_exit()//系统调用

    我们可以用(echo $?)查看上一次进程执行结束的退出码。

    来看下面一个例子:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    int main()
    {
        printf("hello world\n");
        exit(2);
        printf("continue\n");
        return 3;                                      
    }
    

     

    按照我们上面讲的,当这个程序执行结束后,我们查看退出码:发现从exit(2)处将进程结束了。退出码为exit()的参数。

     

    再来看看exit(),和_exit()的区别吧: 

     
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    int main()
    {
     printf("hello world");
     sleep(2);
     exit(2);
    }

     

    执行结果为:等待2秒之后打印"hello world",进程结束

    include <stdio.h>                                                                                                                   #include <stdlib.h>
    #include <unistd.h>
    int main()
    {
        printf("hello world");
        sleep(2);
        _exit(2);
    }
    

     

     

    等待两秒之后,没有进行输出字符串,进程结束。

    这里为什会先等2秒再打印,因为这里的printf()是按行刷新的,但是这里并没有'\n'就不会按行刷新缓冲区,等到进程结束再刷新缓冲区,进行输出,切记,这里不可以理解为sleep(),在printf()之前执行。

    exit()和_exit()都是进程正常退出的的方法,从上面的例子可以看到,_exit(),就是将进程强行退出,而exit()在这里做了一些事情,执行用户定义的清理函数,还有这里可以看到的刷新缓冲区,还有关闭文件流等

    二、进程等待:

    在之前讲进程状态是讲过,如果子进程退出,而父进程对其不管不顾,就有可能造成僵尸进程,而造成内存泄露,而且父进程创建的子进程是为了让其执行任务,当然父进程需要知道子进程任务完成的如何,那么父进程就需要通过进程等待的方式来回收子进程资源,获取子进程推出状态。

    pid_t wait(int *status);

    我们称其为阻塞式等待,等待成功之前父进程处于阻塞状态。

    返回值: 等待成功为被等待进程的pid,失败为-1.

    参数:输出型参数,获取子进程的退出状态,不关心则可以设置为NULL 。

     

    pid_t waitpid(pid_t pid,int *status,int options);

    第一个参数:pid>0代表等待指定的进程。pid=-1,代表等待任意一个进程

    第二个参数:输出型参数,获取子进程的推出状态,不关心则可以设置为NULL。

    第三个参数://TODO下面有讲到

    返回值:若等待成功该值为被等待的进程的pid,否则为-1。

     

    这里的进程退出状态不能简单的当作int类型来看,可以当作位图来看,具体细节如下图示:

     

    我们可以根据退出状态的低7位是否位0来判断进程是否是正常终止的

    (一)wait()

    如果父进程创建了多个子进程,要保证wait()调用次数和子进程数量个数相同

    #include <stdio.h>                                                                                                                                                                                                                                                           
    #include <unistd.h>
    #include <sys/wait.h>
    #include <stdlib.h>
    #include <sys/types.h>
    
    int main()
    {
    
        pid_t id=fork();
        if(id<0)
        {
            perror("fork");
            exit(1);
        }
        if(id==0)
        {//child1
            printf("child 1 pid:%d\n",getpid());
            exit(0);
        }
        if(id>0)
        {
            pid_t pid=fork();
            if(pid<0)
            {
                perror("fork");
                exit(1);
            }
            if(pid==0)
            {//child 2
                printf("child 2 pid: %d\n",getpid());
                sleep(1);
                exit(0);
            }
            if(pid>0)
            {//father
            printf("parent pid:%d\n",getpid());
            wait(NULL);//这里父进程只等待了一次
            while(1)
            {
            sleep(1);
    
            }
    
            }
    
        }
    }
    

     

    上面的父进程创建了两个子进程,但是只等待了一次,并且并不确定等待是哪个子进程,这样就会出现僵尸进程

     

    (二)waitpid()

    可以根据第3个字节求出退出状态。

    include <stdio.h>                                                                                                                                                                                                                                                           
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/wait.h>
    int main()
    {
        pid_t pi=fork();
        if(pi<0)
        {
            perror("fork");
        }
        else
        {
            if(pi==0)
            {//child
                int count=3;
                while(count--)
                {
                    printf("child:%d  %d\n",getpid(),getppid());
                    sleep(1);
                }
                printf("child quit\n");
                exit(13);//注意这里退出码为13
            }
            else
            {
                int status;
                printf("father:%d\n",getpid());
                pid_t ret=waitpid(pi,&status,0);
                if(ret)
                {
                    printf("sig:%d,exit code:%d\n",status&0x7f,(status>>8)&0xff);
                }
                printf("father quit\n");
            }
        }
        _exit(2);
    }
    

     

     

    这里可以了解到进程时正常退出的,并且退出码为13

    再来看一种情况,我们让进程异常退出,在进程运行中,将进程kill掉(在另外一个终端下进行)

    #include <stdio.h>                                                                                                                  #include <stdlib.h>
    #include <unistd.h>
    #include <sys/wait.h>
    int main()
    {
        pid_t pi=fork();
        if(pi<0)
        {
            perror("fork");
        }
        else
        {
            if(pi==0)
            {//child
                int count=100;//这里设置大一点的数
                while(count--)
                {
                    printf("child:%d  %d\n",getpid(),getppid());
                    sleep(1);
                }
                printf("child quit\n");
                exit(13);//注意这里退出码为13
            }
            else
            {
                int status;
                printf("father:%d\n",getpid());
                pid_t ret=waitpid(pi,&status,0);
                if(ret)
                {
                    printf("sig:%d,exit code:%d\n",status&0x7f,(status>>8)&0xff);
                        //   status&0x7f拿到后7位,看是否正常退出
                        //    (status>>8)&0xff拿到第三个字节,即退出状态
                }
                printf("father quit\n");
            }
        }
        _exit(2);
    }

    运行之后,在另一终端下将子进程kill掉,

     

     

    看到上面用的时9号信号将进程异常终止的,所以状态中的信号位置就为9,

    上面是我们自己计算的终止信号和退出状态,其实系统中有两者宏供我们使用(但是我老记不住)

    WIFEXITED(status)//(相当于(status&0x7f==0) ,查看进程是否正常退出) 为真 则表示正常退出则为进程退出状态,

    WEXITSTATUS(status)//(相当于 (status>>8)&0xff)上面WIFEXITED为真,则提取退出码

    例如下面代码

     
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/wait.h>
    int main()
    {
        pid_t pi=fork();
        if(pi<0) 
        {
            perror("fork");
        } 
        else 
        { 
            if(pi==0) 
            {//child 
                int count=3; 
                while(count--) 
                {
                    printf("child:%d %d\n",getpid(),getppid()); sleep(1); 
                } 
                printf("child quit\n");
                exit(13);//注意这里退出码为13 
            } 
            else 
            {
                int status;
                printf("father:%d\n",getpid());
                pid_t ret=waitpid(pi,&status,0);
                if(ret) 
                { 
                    if( WIFEXITED(status)) 
                    printf("exit code:%d\n",WEXITSTATUS(status));
                    else 
                    {
                         printf("异常终止\n");
                    }
                }
                printf("father quit\n");
            } 
        }
     
        exit(0);
    }
    
    
    
    
    

     

    (三)非阻塞式等待

    在上面两种等待的方式,父进程都是在等待的时候处于阻塞状态,当在waitpid()中的第三个参数为WNOHANG是,这时就是非阻塞式等待

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/wait.h>
    int main()
    { 
        pid_t pi=fork();
        if(pi<0) 
        { 
            perror("fork"); 
        } 
        else 
        { 
            if(pi==0)
            {//child 
                int count=3;
                while(count--) 
                { 
                    printf("child:%d %d\n",getpid(),getppid()); 
                    sleep(3); 
                }
                printf("child quit\n");
                exit(13);
                //注意这里退出码为13
            } 
            else
            {//father 
                int status; 
                printf("father:%d\n",getpid()); 
                while(1)
                { 
                    pid_t ret=waitpid(pi,&status,WNOHANG);
                    if(ret>0) 
                    {//等待到子进程
                        if( WIFEXITED(status)) 
                        printf("exit code:%d\n",WEXITSTATUS(status));
                        break;
                    }
                    else 
                    { 
                        if(ret==0)
                        {//等待的子进程没有结束,不予等待,去做别的事情
                            printf("child if running ,to do other thing\n"); 
                        } 
                        else
                        {
                            //错误状态 break;
                        }
                    }
                    sleep(1); 
                } 
                printf("father quit\n"); 
            } 
        } 
        exit(0);
    } 

     

             

     

     

     

     

     

    看到上面这种非阻塞式等待,父进程以循环的方式来查看子进程是否结束(等待子进程结束),若此时子进程没有结束,父进程可以转去做别的事情,而不是阻塞在这里啥也不做。

     

    当父进程有多个子进程时:

    此处应用的时轮询式非阻塞式等待

     

     

    include <stdio.h>                                                                                                                                           
    #include <unistd.h>
    #include <sys/wait.h>
    #include <stdlib.h>
    #include <sys/types.h>
    
    int main()
    {
        pid_t id=fork();
        if(id<0)
        {
            perror("fork");
            exit(1);
        }
        if(id==0)
        {//child1
            printf("child 1 pid:%d\n",getpid());
            sleep(1);
            exit(0);
        }
        if(id>0)
        {
            pid_t pid=fork();
            if(pid<0)
            {
                perror("fork");
          exit(1);
            }
            if(pid==0)
            {//child 2
                printf("child 2 pid: %d\n",getpid());
                sleep(1);
                exit(0);
            }
            if(pid>0)
            {//father
            printf("parent pid:%d\n",getpid());
            int ret=0;
                while(1)
                {
                    if((ret=waitpid(-1,NULL,WNOHANG))==0)
                    {//说明没有等待子进程
                        printf("Do other thing\n");
                    }
                    if(ret<0)
                    {//说明父进程已经没有进程可以等待了
                        break;
                    }
                    if(ret>0)
                    {//说明父进程等到了一个子进程                                                                                                                
                        printf("Wait child pid:%d\n",ret);
                    }
                    sleep(1);
                }
            }
        }
    }            

     

     

    自己之前的一个问题没有解决:

    Makefile 编写时用.PHONY定义一个伪目标,当我们普通的目标make时会根据依赖文件修改时间和目标生成时间来判断是否还需要执行编译语句,但是定义为伪目标的话会每次都认为是依赖文件每次都是最新的,所以每次都会重新生成伪目标,

    静态链接:将静态库文件(.a)在程序的链接阶段被复制到程序中

    动态链接:将动态库文件(.so)在程序运行时由系统自行的加载到内存中

     

     

     

     

    展开全文
  • 操作系统进程状态状态转换详解

    千次阅读 多人点赞 2019-11-01 10:28:55
    进程状态的转换与PCB详解 ​ 返回主目录 ​ 之前的有博文对进程和线程的区别进行了详细的介绍,并且说明了引入进程的目的是为了能够使程序并发的执行,并且可以对并发执行的程序加以描述和控制。这篇博文,我们...
  • 1.一个进程处于(   )状态时, 称为就绪状态。 编号 选项 A 等待输入数据 B 等待调度 C 等待分配进程控制块 D 等待进入内存 2.一个进程处于下述(  )状态时,属于阻塞状态。 ...
  • 进程状态及转换

    千次阅读 2018-07-27 17:27:29
    进程是计算机中已运行程序的实体。 程序本身只是指令的集合,进程才是程序的真正运行。用户下达运行程序的命令后,就会产生进程。...进程通常有如下5种状态,其中前3种是进程的基本状态: 就绪...
  • linux C进程 进程等待wait与waitpid函数

    千次阅读 2017-11-26 12:20:04
    编程过程中,有时需要让一个进程等待另一个进程,最常见的是父进程等待自己的子进程,或者父进程回收自己的子进程资源包括僵尸进程。 1. 孤儿进程:父进程先于子进程结束,则子进程成为孤儿进程,子进程的父进程...
  • 进程状态及其转换

    2019-08-31 22:46:49
    ③就绪:一个处于等待状态进程因等待事件发生唤醒后,又因不可能立即得到处理机而进入就绪状态。 ④初始:进程刚被创建,由于其他进程正占有处理机而得不到执行,只能处于初始状态。 ...
  • 进程的几种状态

    万次阅读 2016-07-28 19:53:57
    进程状态:一个进程的生命周期可以划分为一组状态,这些状态刻画了整个进程进程状态即体现一个进程的生命状态进程状态: 一般来说,进程有三个状态,即就绪状态,运行状态,阻塞状态。 运行态:进程占用CPU,并...
  • 封闭性:程序在封闭环境下执行,程序运行占全机资源,资源的状态只有该程序才能改变,一旦程序开始执行,结果不受外界影响; 可再现性:初始状态和执行环境相同的条件下,程序反复执行,结果不变; 并发执行的...
  • 进程状态状态转换图,状态转换条件
  • 进程的5种状态

    千次阅读 2020-12-10 14:55:14
    一个完整的进程状态的变迁如下图: 再来详细说明一下进程状态变迁: NULL -> 创建状态:一个新进程被创建的第一个... 结束状态当进程已经运行完成或出错,会被操作系统作结束状态处理; 运.
  • 操作系统——进程状态与转换

    千次阅读 2019-08-30 09:40:41
    在单处理机环境下,每一时刻最多只有一个进程处于运行状态; 就绪状态:进程已处于准备运行的状态,获得了除处理机之外的一切所需资源,一旦得到处理机即可运行。 阻塞状态,又称等待状态:进程正在等待某一事件而...
  • 阻塞状态和等待状态的区别

    千次阅读 2020-10-27 14:39:05
    在进入synchronized方法之前因为抢不到锁对象而进入阻塞状态,进入阻塞队列。进入到synchronized方法后由于调用了wait()方法而进入等待状态,此时进入等待队列,等待其它线程调用它的notify()方法将他唤醒。 ...
  • 【Linux】Linux进程简介及其五种状态

    万次阅读 2018-07-24 21:42:36
    由操作系统定义,并由操作系统所操控的一个特殊的数据结构实例叫做进程。它连接了用户代码,拥有代码运行所需的独立内存空间,在调度器的调度下使用分配给它的处理器时间片来运行。   进程及其私有内存空间 进程...
  • 操作系统之进程状态和转换详解

    万次阅读 多人点赞 2017-04-22 19:15:31
    进程状态和转换三态模型一个进程从创建而产生至撤销而消亡的整个生命周期,可以用一组状态加以刻划,根据三态模型,进程的生命周期可分为如下三种进程状态: 1. 运行态(running):占有处理器正在运行 2. 就绪态...
  • 进程的终止方式和进程状态

    千次阅读 2018-12-18 11:51:27
    进程的终止方式: 有8种方式使进程终止,其中前5种为正常终止,它们是 1:从 main 返回 2:调用 exit 3:调用 _exit 或 _Exit 4:最后一个线程从其启动例程返回 ...Linux进程状态:R (TASK_RU...
  • 进程的基本状态

    千次阅读 2017-09-06 19:54:46
    就绪状态:这是指进程已经处于准备好运行的状态,即进程已经分配到所需资源,除了CPU,只要获得CPU便可立即执行。 阻塞状态:指正在执行的进程由于某些事件(如I/O请求,申请缓存区失败)而暂时无法运行,进程受到...
  • ps命令显示进程状态解析

    千次阅读 2018-11-01 10:39:24
    我们知道进程分为如下几种状态: 运行(正在运行或在运行队列中等待) 中断(休眠中, 受阻, 在等待某个条件的形成或接受到信号) 不可中断(收到信号不唤醒和不可运行, 进程必须等待直到有中断发生) 僵死(进程已...
  • 进程的挂起状态详细分析

    万次阅读 多人点赞 2016-12-11 00:03:24
    通常我们所认为的进程有五大状态,新建态,就绪态,阻塞态,运行态,退出态。  下面是示意图:  事实上还存在被挂起的进程。    交换的需要 前面图中三个基本状态(就绪态、运行态和阻塞态)提供了一种为进程...
  • 进程状态(含状态变迁图)

    万次阅读 多人点赞 2017-08-20 10:49:31
    (1)就绪:一个进程获得了除处理机以外的一切所需资源,一旦得到处理机即可运行,则称此进程处于就绪状态。就绪进程可以按多个优先级来划分队列。例如,一个进程由于时间片用完而进入就绪状态时,排入低优先级...
  • 进程控制:状态、调度和优先级

    千次阅读 2019-05-02 21:05:31
    睡眠进程等待队列 TASK_KILLABLE 状态 TASK_STOPPED 状态和 TASK_TRACED 状态 EXIT_ZOMBIE 状态和 EXIT_DEAD 状态 进程调度概述 普通进程的优先级 完全公平调度的实现 普通进程的组调度 实时进程 CPU 的...
  • 进程的三种基本状态

    万次阅读 2015-10-29 22:45:04
     当进程已分配到除CPU以外的所有必要的资源,只要获得处理机便可立即执行,这时的进程状态称为就绪状态。  执行(Running)状态  当进程已获得处理机,其程序正在处理机上执行,此时的进程状态称为执行状态...
  • 在这个执行过程中,有时进程正在被CPU处理,有时又需要等待CPU的服务,可见,进程存在多种状态。为了方便对各个进程的管理,操作系统需要将进程合理地划分为几种状态。 下面介绍进程的三种基本状态和另外两种状态。...
  • 进程状态

    千次阅读 2016-08-01 17:08:34
    调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去 就绪原因:  缺少cpu 阻塞原因  1.内存资源紧张 2. 无就绪队列,处理机空闲 3 .I/O速度比处理机速度慢的多,可能...
  • 进程从创建到结束的状态

    千次阅读 2019-08-10 17:13:58
    进程从刚开始被创建出来,是处于TASK_RUNNING(就绪态),进程被放在等待队列中排队等待系统调度。 linux内核中的函数sched()称为调度器,它会根据各种参数来选择一个等待进程去占用cpu,当进程占用了cpu后,就从...
  • 线程、进程状态

    千次阅读 2018-04-04 11:18:34
    即在就绪状态进程除了CPU之外,其他的运行所需资源都已全部获得。2.1、就绪状态只是说有资格运行,调度程序没有挑选到你,你就永远是可运行状态。2.2、调用线程的start()方法,此线程进入就绪状态。2.3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 209,105
精华内容 83,642
关键字:

当进程处于等待状态时