精华内容
下载资源
问答
  • C++进程优先级调度进程优先级调度进程优先级调度C++进程优先级调度进程优先级调度进程优先级调度
  • 进程优先级

    2018-07-11 15:17:00
    一、 进程优先级进程可划分为普通进程和实时进程,那么优先级与nice值的关系图:优先级值越小表示进程优先级越高,3个进程优先级的概念:静态优先级: 不会时间而改变,内核也不会修改,只能通过系统调用改变nice值...

    线程与进程的最大区别就是是否共享父进程的地址空间,内核角度来看没有线程与进程之分,都用task_struct结构体来表示,调度器操作的实体便是task_struct。

    一、 进程优先级

    进程可划分为普通进程和实时进程,那么优先级与nice值的关系图:

    nice_prio

    优先级值越小表示进程优先级越高,3个进程优先级的概念:

    • 静态优先级: 不会时间而改变,内核也不会修改,只能通过系统调用改变nice值的方法区修改。优先级映射公式: static_prio = MAX_RT_PRIO + nice + 20,其中MAX_RT_PRIO = 100,那么取值区间为[100, 139];对应普通进程;

    • 实时优先级:只对实时进程有意义,取值区间为[0, MAX_RT_PRIO -1],其中MAX_RT_PRIO = 100,那么取值区间为[0, 99];对应实时进程;

    • 动态优先级: 调度程序通过增加或减少进程静态优先级的值,来达到奖励IO消耗型或惩罚cpu消耗型的进程,调整后的进程称为动态优先级。区间范围[0, MX_PRIO-1],其中MX_PRIO = 140,那么取值区间为[0,139]

    nice值

    nice∈[-20, 19],可通过adb直接修改某个进程的nice值: renice prio pid

    二、 Framework调度策略

    代码路径: framework/base/core/android/os/Process.java

    2.1 进程优先级

    Android进程优先级,总分10级

    优先级调度方法:

    setThreadPriority(int tid, int priority)
    

    进程优先级级别:

    进程优先级nice值解释
    THREAD_PRIORITY_LOWEST19最低优先级
    THREAD_PRIORITY_BACKGROUND10后台
    THREAD_PRIORITY_LESS_FAVORABLE1比默认略低
    THREAD_PRIORITY_DEFAULT0默认
    THREAD_PRIORITY_MORE_FAVORABLE-1比默认略高
    THREAD_PRIORITY_FOREGROUND-2前台
    THREAD_PRIORITY_DISPLAY-4显示相关
    THREAD_PRIORITY_URGENT_DISPLAY-8显示(更为重要),input事件
    THREAD_PRIORITY_AUDIO-16音频相关
    THREAD_PRIORITY_URGENT_AUDIO-19音频(更为重要)

    2.2 组优先级

    进程/线程组优先级调度方法:

    setProcessGroup(int pid, int group)
    setThreadGroup(int tid, int group)
    

    进程组优先级级别:

    组优先级取值解释
    THREAD_GROUP_DEFAULT-1仅用于setProcessGroup,将优先级<=10的进程提升到-2
    THREAD_GROUP_BG_NONINTERACTIVE0CPU分时的时长缩短
    THREAD_GROUP_FOREGROUND1CPU分时的时长正常
    THREAD_GROUP_SYSTEM2系统线程组
    THREAD_GROUP_AUDIO_APP3应用程序音频
    THREAD_GROUP_AUDIO_SYS4系统程序音频

    2.3 调度器选择

    调度器设置方法:

    setThreadScheduler(int tid, int policy, int priority)
    

    调度器类别

    调度器名称解释
    SCHED_OTHER默认标准round-robin分时共享策略
    SCHED_BATCH批处理调度针对具有batch风格(批处理)进程的调度策略
    SCHED_IDLE空闲调度针对优先级非常低的适合在后台运行的进程
    SCHED_FIFO先进先出实时调度策略,android暂未实现
    SCHED_RR循环调度实时调度策略,android暂未实现

    三、 Kernel调度策略

    设置优先级,Kernel不区别线程和进程,都对应同一个数据结构Task。Linux kernel用nicer值来描述进程的调度优先级,该值越大,表明该进程越友(nice),其被调度运行的几率越低。

    3.1 优先级

    int setpriority(int which, int who, int prio);
    

    参数说明:

    • which和who参数联合使用:
      • 当which为PRIO_PROGRESS时,who代表一个进程;
      • 当which为PRIO_PGROUP时,who代表一个进程组;
      • 当which为PRIO_USER时,who代表一个uid。
    • prio参数用于设置应用进程的nicer值,可取范围从-20到19。

    3.2 调度器

    int sched_setscheduler(pid_t pid, int policy, conststruct sched_param *param);
    

    参数说明:

    • pid为进程id;
    • policy为调度策略;
    • param最重要的是该结构体中的sched_priority变量;
      • 针对Android中的三种非实时Scheduler策略,该值必须为NULL。

    选择和设置合理的进程优先级和调度器是性能优化的一个方向,后续再以内核调度器的角度来分析调度策略的抉择问题。

    展开全文
  • 【Android 进程保活】提升进程优先级 ( 1 像素 Activity 提高进程优先级 | taskAffinity 亲和性说明 | 运行效果 | 源码资源 ) https://hanshuliang.blog.csdn.net/article/details/115482010 博客源码快照
  • 【Android 进程保活】提升进程优先级 ( 使用前台 Service 提高应用进程优先级 | 启动相同 id 的第二个前台 Service 关闭通知 ) https://hanshuliang.blog.csdn.net/article/details/115531653 博客源码快照
  • 【Android 进程保活】提升进程优先级 ( 使用前台 Service 提高应用进程优先级 | 启动相同 id 的第二个前台 Service 关闭通知 ) https://hanshuliang.blog.csdn.net/article/details/115531653 博客源码快照
  • 最近研发的产品出了点小bug,最后查到根本原因是,其中一个进程A使用基于FIFO的实时进程优先级,而另一个进程B是使用普通调度的进程优先级,而A和B两个进程是互相通信的,进程B会被饿死,而进程A也不能正常工作。...

     

    前言

    出处@https://www.cnblogs.com/qinwanlin/p/8631185.html

    最近研发的产品出了点小bug,最后查到根本原因是,其中一个进程A使用基于FIFO的实时进程优先级,而另一个进程B是使用普通调度的进程优先级,而A和B两个进程是互相通信的,进程B会被饿死,而进程A也不能正常工作。分析问题过程中查找了一些资料,以下记录一些特别注意的点。

    Linux进程调度的三种策略

    (1)SCHED_OTHER,分时调度策略

    (2)SCHED_FIFO,实时调度策略,先到先服务

    (3)SCHED_RR,实时调度策略,时间片轮转 

    由于相关内容比较多,本人也末必比别人讲得更清楚,关于进程调度更详细的内容建议读《深入理解Linux内核》,网上的很多内容都是从此而来,也不一定比这本书讲得好。另可参考此链接

    https://blog.csdn.net/maximuszhou/article/details/42042161

    前面遇到bug的进程A就是使用SCHED_FIFO调度策略的,而进程B没有经过设置,默认是SCHED_OTHER。

    如何设置为实时进程

    查找资料的时候发现有个链接问,为什么设置FIFO策略,但和预想的不一致。链接在此 http://ask.csdn.net/questions/254095

    从代码看是因为设置的方法不对,直接上代码,可以设置进程和线程的调度策略
     

    复制代码

     1  #include <stdio.h>
     2 #include <stdlib.h>
     3 #include <pthread.h>
     4 #include <sched.h>
     5 
     6 
     7 pid_t pid = getpid();
     8 struct sched_param param;
     9 param.sched_priority = sched_get_priority_max(SCHED_FIFO);   // 也可用SCHED_RR
    10 sched_setscheduler(pid, SCHED_RR, &param);                   // 设置当前进程
    11 pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);   // 设置当前线程

    复制代码

    可以通过top命令查看进程是否成功,如果为"rt"表示是实时进程了。如果不成功,可能是权限问题,需要roo权限。

    调整进程优先级

     如果不调整调度策略,也可以提升进程优先级,使得进程得到更多的CPU,特别是交互式程序,用户体检更好。代码很简单,只需要调用nice(int n)函数即可。n的有效范围是-20~19,数值越小表示优先级越高。具体内容不在此复制粘贴,还是看《深入理解Linux内核》比较靠谱。

     

    浅析Linux线程调度

         在Linux中,线程是由进程来实现,线程就是轻量级进程( lightweight process ),因此在Linux中,线程的调度是按照进程的调度方式来进行调度的,也就是说线程是调度单元。Linux这样实现的线程的好处的之一是:线程调度直接使用进程调度就可以了,没必要再搞一个进程内的线程调度器。在Linux中,调度器是基于线程的调度策略(scheduling policy)和静态调度优先级(static scheduling priority)来决定那个线程来运行。

        对于下面三种调度策略SCHED_OTHER, SCHED_IDLE, SCHED_BATCH,其调度优先级sched_priority是不起作用的,即可以看成其调度优先级为0;调度策略SCHED_FIFO和SCHED_RR是实时策略,他们的调度值范围是1到99,数值越大优先级越高,另外实时调度策略的线程总是比前面三种通常的调度策略优先级更高。通常,调度器会为每个可能的调度优先级(sched_priority value)维护一个可运行的线程列表,并且是以最高静态优先级列表头部的线程作为下次调度的线程。所有的调度都是抢占式的:如果一个具有更高静态优先级的线程转换为可以运行了,那么当前运行的线程会被强制进入其等待的队列中。下面介绍几种常见的调度策略:

        SCHED_OTHER:该策略是是默认的Linux分时调度(time-sharing scheduling)策略,它是Linux线程默认的调度策略。SCHED_OTHER策略的静态优先级总是为0,对于该策略列表上的线程,调度器是基于动态优先级(dynamic priority)来调度的,动态优先级是跟nice中相关(nice值可以由接口nice, setpriority,sched_setattr来设置),该值会随着线程的运行时间而动态改变,以确保所有具有SCHED_OTHER策略的线程公平运行。在Linux上,nice值的范围是-20到+19,默认值为0;nice值越大则优先级越低,相比高nice值(低优先级)的进程,低nice值(高优先级)的进程可以获得更多的处理器时间。使用命令ps -el查看系统的进程列表,其中NI列就是进程对应的nice值;使用top命令,看到的NI列也是nice值。运行命令的时候可用nice –n xx cmd来调整cmd任务的nice值,xx的范围是-20~19之间。

        SCHED_FIFO:先入先出调度策略(First in-first out scheduling)。该策略简单的说就是一旦线程占用cpu则一直运行,一直运行直到有更高优先级任务到达或自己放弃。

        SCHED_RR:时间片轮转调度(Round-robin scheduling)。该策略是SCHED_FIFO基础上改进来的,他给每个线程增加了一个时间片限制,当时间片用完后,系统将把该线程置于队列末尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平。使用top命令,如果PR列的值为RT,则说明该进程采用的是实时策略,即调度策略是SCHED_FIFO或者为SCHED_RR,而对于非实时调度策略(比如SCHED_OTHER)的进程,该列的值是NI+20,以供Linux内核使用。我们可以通过命令:

     

    ps -eo state,uid,pid,ppid,rtprio,time,comm

     

    来查看进程对应的实时优先级(位于RTPRIO列下),如果有进程对应的列显示“-”,则说明它不是实时进程。注意任何实时策略进程的优先级都高于普通的进程,也就说实时优先级和nice优先级处于互不相交的两个范畴。

     

        在Linux中,与调度相关的常见接口如下:

     

    
     
    1. #include <sched.h>

    2. int sched_get_priority_max(int policy);

     

    该接口获取指定调度策略可以设置的最大优先级,类似的 sched_get_priority_min接口获取调度策略可以设置的最小优先级。在Linux中,对于SCHED_FIFO和SCHED_RR调度策略其优先级为1到99,其他调度策略优先级为0。注意在不同系统上,这个优先级范围可能不一样。

     

    
     
    1. #include <pthread.h>

    2. int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

     

    该接口可以用来设置线程的调度策略,即设置线程属性attr。参数policy可以是CHED_FIFO, SCHED_RR和SCHED_OTHER。系统创建线程时,默认的线程调度策略是SCHED_OTHER。类似可以通过接口

     

    int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)

     

    获取线程的调度策略。

     

    
     
    1. #include <pthread.h>

    2. int pthread_attr_setschedparam(pthread_attr_t *attr,

    3. const struct sched_param *param);

     

    该接口可以用来设置线程的调度优先级。结构sched_param定义如下:

     

    
     
    1. struct sched_param {

    2. int sched_priority; /* Scheduling priority */

    3. };

     

    类似的的接口,可以用来获取线程调度的优先级:

     

    
     
    1. int pthread_attr_getschedparam(const pthread_attr_t *attr,

    2. struct sched_param *param);

    
     
    1. #include <sched.h>

    2. int sched_yield(void);

     

    调用该接口可以使得当前线程主动交出CPU,并把该线程放到相应调度队列的末尾。如果当前线程是最高优先级队列中唯一的线程,则在调用sched_yield后,该线程继续保持运行。

     

    
     
    1. #include <sched.h>

    2. int sched_setaffinity(pid_t pid,

    3. size_t cpusetsize,const cpu_set_t *mask);

     

    该接口可以用来设置线程的CPU亲和性(CPU affinity),设置线程的亲和性可以使得线程绑定到一个或多个指定的CPU上运行。在多处理器系统上,设置CPU亲和性可以提高性能(主要原因是尽可能避免了cache失效和切换到其他CPU的消耗)。CPU亲和性掩码是由cpu_set_t结果来实现的,该结构体需要用预定义好的宏来操作;参数pid是指定线程的TID,可以通过gettid()来获取,即线程在内核中对应进程id,若pid为0,则设置的是调用线程的CPU亲和性,注意用getpid()获取的是主线程的id;参数cpusetsize的值通常是mask的大小,即sizeof(mask)。除了这个接口外,设置线程亲和性接口还有:

     

    
     
    1. #include <pthread.h>

    2. int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize,

    3. const cpu_set_t *cpuset);

    4. int pthread_attr_setaffinity_np(pthread_attr_t *attr,

    5. size_t cpusetsize, const cpu_set_t *cpuset);

     

    通过fork创建的子进程继承父进程的CPU亲和性,通过 execve()后,亲和性仍然保持不变。我们可以下面命令来查看多核cpu的负载:

        I)cat /proc/cpuinfo  查看所有cpu的信息;

        II)top命令,然后再输入1,则显示多个cpu的使用信息;

        III)top命令,然后按下f,进入top Current Fields设置页面,然后按下j,表示要求显示进程使用那个cpu,回车后,回到刚才界面,此时P 显示此进程使用哪个CPU。

     

        下面是测试代码:

     

    
     
    1. #include <stdio.h>

    2. #include <pthread.h>

    3. #include <sched.h>

    4. #include <assert.h>

    5.  
    6. static int get_thread_policy(pthread_attr_t *attr)

    7. {

    8. int policy;

    9. int rs = pthread_attr_getschedpolicy(attr,&policy);

    10. assert(rs==0);

    11.  
    12. switch(policy)

    13. {

    14. case SCHED_FIFO:

    15. printf("policy=SCHED_FIFO\n");

    16. break;

    17.  
    18. case SCHED_RR:

    19. printf("policy=SCHED_RR\n");

    20. break;

    21.  
    22. case SCHED_OTHER:

    23. printf("policy=SCHED_OTHER\n");

    24. break;

    25.  
    26. default:

    27. printf("policy=UNKNOWN\n");

    28. break;

    29. }

    30. return policy;

    31. }

    32.  
    33. static void show_thread_priority(pthread_attr_t *attr,int policy)

    34. {

    35. int priority = sched_get_priority_max(policy);

    36. assert(priority != -1);

    37. printf("max_priority=%d\n",priority);

    38.  
    39. priority= sched_get_priority_min(policy);

    40. assert(priority != -1);

    41. printf("min_priority=%d\n",priority);

    42. }

    43.  
    44. static int get_thread_priority(pthread_attr_t *attr)

    45. {

    46. struct sched_param param;

    47. int rs = pthread_attr_getschedparam(attr,¶m);

    48. assert(rs == 0);

    49.  
    50. printf("priority=%d\n",param.__sched_priority);

    51. return param.__sched_priority;

    52. }

    53.  
    54. static void set_thread_policy(pthread_attr_t *attr,int policy)

    55. {

    56. int rs = pthread_attr_setschedpolicy(attr,policy);

    57. assert(rs==0);

    58. }

    59.  
    60. int main(void)

    61. {

    62. pthread_attr_t attr;

    63. int rs;

    64.  
    65. rs = pthread_attr_init(&attr);

    66. assert(rs==0);

    67.  
    68. int policy = get_thread_policy(&attr);

    69.  
    70. printf("Show current configuration of priority\n");

    71. get_thread_policy(&attr);

    72. show_thread_priority(&attr,policy);

    73.  
    74. printf("show SCHED_FIFO of priority\n");

    75. show_thread_priority(&attr,SCHED_FIFO);

    76.  
    77. printf("show SCHED_RR of priority\n");

    78. show_thread_priority(&attr,SCHED_RR);

    79.  
    80. printf("show priority of current thread\n");

    81. get_thread_priority(&attr);

    82.  
    83. printf("Set thread policy\n");

    84.  
    85. printf("set SCHED_FIFO policy\n");

    86. set_thread_policy(&attr,SCHED_FIFO);

    87. get_thread_policy(&attr);

    88. get_thread_priority(&attr);

    89.  
    90. printf("set SCHED_RR policy\n");

    91. set_thread_policy(&attr,SCHED_RR);

    92. get_thread_policy(&attr);

    93.  
    94. printf("Restore current policy\n");

    95. set_thread_policy(&attr,policy);

    96. get_thread_priority(&attr);

    97.  
    98. rs = pthread_attr_destroy(&attr);

    99. assert(rs==0);

    100.  
    101. return 0;

    102. }

     

    编译和运行程序结果如下:

     

    
     
    1. $gcc -Wall -lpthread hack_thread_sched.c -o hack_thread_sched

    2. $./hack_thread_sched

    3. policy=SCHED_OTHER

    4. Show current configuration of priority

    5. policy=SCHED_OTHER

    6. max_priority=0

    7. min_priority=0

    8. show SCHED_FIFO of priority

    9. max_priority=99

    10. min_priority=1

    11. show SCHED_RR of priority

    12. max_priority=99

    13. min_priority=1

    14. show priority of current thread

    15. priority=0

    16. Set thread policy

    17. set SCHED_FIFO policy

    18. policy=SCHED_FIFO

    19. priority=0

    20. set SCHED_RR policy

    21. policy=SCHED_RR

    22. Restore current policy

    23. priority=0

     

    从输出结果,我们可以看到:

        I)线程默认的调度策略为SCHED_OTHER,并且最大和最小调度优先级都是0。

        II)调度策略SCHED_FIFO和SCHED_RR的优先级范围为1到99,并且初始设置时对应的调度优先级初始值为0。

        在Linux中,调度程序是一个叫schedule()的函数,该函数调用的频率很高,由它来决定是否要执行进程的切换,如果要切换的话,切换到那个进程等。那么在Linux中,在什么情况下要执行这个调度程序呢?我们把这种情况叫作调度时机。Linux调度时机主要有:

       I)进程状态转换的时刻:进程终止、进程睡眠(比如I/O阻塞就会导致这种情况),还比如进程调用sleep()或exit()等函数进行状态转换。 

       II)当前进程的时间片用完时。

         III)设备驱动程序,当设备驱动程序执行长而重复的任务时,在每次反复循环中,驱动程序读检查是否需要调度,如果必要,则调用调度程序schedule()放弃CPU。

         IV)进程从中断、异常及系统调用返回到用户态时。

     

     

    展开全文
  • 调整进程优先级,让你的程序获得更多资源,从尔运行更快。
  • Linux进程优先级

    2020-10-10 14:49:04
    Linux进程优先级1.进程优先级1.1 基本概念1.2 优先级取值范围2.查看进程优先级 1.进程优先级 1.1 基本概念 由于系统中进程数量众多,而CPU资源比较少甚至只有一个,进程之间需要竞争来使用CPU。这时让一个比较重要、...

    1.进程优先级

    1.1 基本概念

    由于系统中进程数量众多,而CPU资源比较少甚至只有一个,进程之间需要竞争来使用CPU。这时让一个比较重要、需要优先执行的进程去和其他进程竞争,显然是不合理的。为了更合理的分配CPU资源, 就有了进程优先级。

    优先级高的进程有优先执行的权利。此外,优先级还影响分配给进程的时间片长短。 重要的进程,应该分配多一些cpu时间片,好让其尽快完成任务。所有的进程都会有机会运行,但优先级高的进程会获取更多的cpu执行时间。配置进程优先级对多任务环境的Linux很有用,可以改善系统性能。

    1.2 优先级取值范围

    实时进程与非实时进程

    • 和其他操作系统类似,Linux也支持两种进程:实时进程和非实时进程。 实时进程具有一定程度上的紧迫性,要求对外部事件做出非常快的响应;而非实时进程则没有这种限制。所以,调度程序要区分对待这两种进程,通常,实时进程要比非实时进程优先运行。实时进程会一直运行直到退出,除非它阻塞才会释放CPU, 实时进程只能被更高优先级的实时进程抢占,任意实时进程比非实时进程的优先级都要高。 这两种进程的区分也反映在task_struct 数据结构中。

    进程优先级取值范围

    在linux系统中,进程优先级的取值范围是0-139 , 而这个值又是由另外两个值组成的,一个是代表实时进程(realtime)优先级范围是[0, 99],另外一个是代表非实时进程,取值范围是[100, 139]。 所以,Linux进程实际上实现了140个优先级范围,取值范围是从 [0, 139],这个值越小,优先级越高。

    • 动态优先级:实时进程优先级, 范围 [0,99],该区间被称为动态优先级,优先级随着进程执行情况的变化而改变,以便获得更好的调度性能。
    • 静态优先级:非实时进程的优先级, 范围[100,139], 该区间被称为静态优先级,该值不会随着时间而进行改变,但系统可以通过nice来进行修改。

    2.查看进程优先级

    在这里插入图片描述
    输入命令 ps -l 即可查看,其中有几个重要的信息:

    • UID : 代表执行者的身份
    • PID : 进程号
    • PPID : 父进程的进程号
    • PRI : 进程优先级, 越小越优先
    • NI : 进程的nice值, 用于调整进程优先级

    同样使用top命令也可查看
    在这里插入图片描述
    PRI 代表的就是进程的优先级. 其值越小, 优先级越高, 即越早的被CPU所执行

    • NI:nice值, nice 是用来修改 PRI 的 , 也就是说用来调整进程优先级的, PRI(new) = PRI(old) + nice。当nice值为负值的时候,那么该程序优先级会变高 (PRI数值降低)。在Linux下,调整进程优先级就是更改NI,也就是nice值,nice的取值为 [ -20 ~ 19 ],一共40个范围。

    • PR:PR是在top 命令执行后的显示,其代表的是进程的静态优先级,与静态优先级(static_priority)关系为 :PR = static_priority - 100。static_priority取值为[100, 139],所以PR取值是 [0, 39]。PR和NI关系为 : PR(new) = PR(old) + nice

    3.调整进程优先级

    用top命令更改已存在进程的nice值来调整进程优先级

    • 执行 top 命令
    • 进入top后输入r ===》输入需要修改的进程的进程号PID ===》再输入nice 的值 , 按回车即可

    其他概念

    • 竞争性: 系统进程数目众多,而CPU资源只有少量,甚至1个,所以进程之间是具有竞争属性的。为了高效完成任务,更合理竞争相关资源,便具有了优先级
    • 独立性: 多进程运行,需要独享各种资源,多进程运行期间互不干扰
    • 并行: 多个进程在多个CPU下分别同时进行运行,这称之为并行
    • 并发: 多个进程在一个CPU下采用进程切换的方式,在一段时间之内,让多个进程都得以推进,称之为并发
    展开全文
  • linux设置进程优先级Fatmawati Achmad Zaenuri/Shutterstock.comFatmawati Achmad Zaenuri / Shutterstock....
    linux设置进程优先级

    linux设置进程优先级

    Bash shell on Ubuntu laptop
    Fatmawati Achmad Zaenuri/Shutterstock.comFatmawati Achmad Zaenuri / Shutterstock.com

    The nice and renice commands let you fine-tune how the kernel treats your processes by adjusting their priorities. Read this tutorial to learn how to use them in Linux and Unix-like operating systems such as macOS.

    nicerenice命令使您可以通过调整优先级来微调内核如何对待进程。 阅读本教程,了解如何在Linux和类似macOS的Unix操作系统中使用它们。

    这都是过程的问题 (It’s All a Matter of Process)

    Inside your Linux or Unix-like computer, there will be many processes running even before you launch the application you want to use. The majority of these processes are vital elements of Linux itself or supporting processes for your graphical desktop environment. There’s a lot going on behind the scenes. Of course, there are only so many system resources and CPU time to go around. The Linux kernel is the controller for all of these processes.

    在Linux或类似Unix的计算机中,甚至在启动要使用的应用程序之前,就会有许多进程在运行。 这些过程中的大多数是Linux本身或图形桌面环境支持过程的重要元素。 幕后发生了很多事情。 当然,只有这么多的系统资源和CPU时间需要花费。 Linux内核是所有这些过程的控制器。

    It is the kernel that has to decide which processes get attention and resources right now, and which ones have to wait. The kernel is continually juggling processes and priorities to ensure that the computer runs as smoothly as it can and that all processes get their appropriate share. Some processes get preferential treatment. They are so important to the general operation of the computer that their needs have to come first ahead of, say, your browser.

    内核必须决定当前哪些进程获得关注和资源,哪些进程必须等待。 内核会不断处理进程和优先级,以确保计算机尽可能平稳地运行,并确保所有进程都能获得适当的份额。 一些过程得到优惠待遇。 它们对于计算机的常规操作非常重要,因此必须首先满足您的需求,例如您的浏览器。

    不错的价值 (The nice Value)

    One of the criteria used to determine how the kernel treats a process is the nice value. Every process has a nice value. The nice value is an integer in the range of -19 to 20. All standard processes are launched with a nice value of zero.

    好的值是用来确定内核如何处理进程的标准之一。 每个过程都有很好的价值。 nice值是介于-19到20之间的整数。所有标准进程均以0的尼斯值启动。

    The trick here is that the higher the nice value, the nicer your process is being to the other processes. In other words, a high nice value tells the kernel that this process is happy to wait. A negative number is the opposite of being nice. The larger the negative nice value, the more selfish the process is. It is trying to get as much CPU time as it can, with no regard for the other processes.

    这里的技巧是,nice值越高,您的过程对其他过程的影响就越好。 换句话说,高nice值告诉内核该过程很高兴等待。 负数与友善相反。 负好值越大,该过程越自私 。 它正在尝试获取尽可能多的CPU时间,而不考虑其他进程。

    We can use the nice command to set the nice value when a process is launched and we can use renice to adjust the nice value of a running process.

    我们可以使用nice命令来设置 启动进程时的nice值,也可以使用renice调整 正在运行的进程的nice值。

    漂亮的命令 (The nice Command)

    We can use the nice command to adjust the nice value for a program as we launch it. This allows us to increase or decrease the priority given to the process by the kernel, relative to the other processes.

    启动程序时,可以使用nice命令调整程序的nice值。 相对于其他进程,这允许我们增加或减少内核赋予进程的优先级。

    Let’s suppose a programmer has written a program called ackermann . This calculates Ackerman functions. It is CPU and memory intensive. The programmer can launch the program with the following command:

    假设程序员编写了一个名为ackermann的程序。 这将计算Ackerman函数 。 它占用大量CPU和内存。 程序员可以使用以下命令启动程序:

    ./ackermann
    
    ackermann command in terminal window

    We can use the top command to view the running program.

    我们可以使用top命令查看正在运行的程序。

    top
    
    top running in a terminal

    We can see the details of the ackermann program in top. The nice value is the figure in the “NI column”. It set to zero as we’d expect.

    我们可以在top看到ackermann程序的详细信息。 好的值是“ NI列”中的数字。 正如我们期望的那样,它设置为零。

    Let’s restart it and this time make it less demanding. We’ll set a nice value of 15 for the ackermann program as follows. Type nice, a space, -15, another space, and then the name of the program you wish to launch. In our example, our fictitious programmer is using ./ackermann.

    让我们重新启动它,这次使它的要求降低了。 我们将为ackermann程序设置一个很好的值为15,如下所示。 键入nice,一个空格,-15,另一个空格,然后输入您要启动的程序的名称。 在我们的示例中,我们的虚拟程序员正在使用./ackermann

    nice -15 ./ackermann
    
    nice 15 command in terminal window

    Take careful note, the “-15” is not negative fifteen. It is positive fifteen. The “-” is required to tell nice we’re passing in a parameter. To indicate a negative number you must type two “-” characters.

    请注意,“-15”不是负数15。 现在是十五岁。 该“ - ”需要告诉nice ,我们正在传递的参数。 要表示一个负数,您必须输入两个“-”字符。

    If we now start top again, we can see the change in the behavior of ackermann.

    如果我们现在开始top再次,我们可以看到的行为的变化ackermann

    top
    
    top running in a terminal

    With a nice value of 15, ackermann is not consuming the most CPU time. GNOME and Rhythmbox are both using more. We’ve reined ackermann in a bit.

    ackermann值为15时,它不会消耗最多的CPU时间。 GNOME和Rhythmbox都在使用更多。 我们稍微控制了ackermann

    Now let’s do the reverse and give ackermann a negative nice value. Note the use of two “-” characters. To make an application more selfish and less nice, you must use sudo. Anyone can make their application more nice, but only superusers can make one more selfish.

    现在,让我们做相反的事情,并为ackermann赋予负的不错的价值。 请注意使用两个“-”字符。 要使应用程序变得更自私和不太友好,必须使用sudo 。 任何人都可以使他们的应用程序更加美观,但是只有超级用户才能使自私。

    sudo nice --10 ./ackermann
    
    nice -10 command in terminal window

    Let’s run top and see what difference that has made.

    让我们来看看有什么不同。

    top
    
    top running in a terminal

    This time ackermann has a nice value of -10. It is back on the top line and consuming more CPU time than before.

    这次ackermann的值为-10。 它重新回到了第一位,并且比以前消耗更多的CPU时间。

    renice命令 (The renice Command)

    The renice command lets us adjust the nice value of a running process. We don’t need to stop it and relaunch it with nice. We can set a new value on-the-fly.

    renice命令使我们可以调整正在运行的进程的精确值。 我们不需要停止它并以nice重新启动它。 我们可以即时设置新值。

    The renice command takes the process ID, or PID, of the process as a command line parameter. We can either extract the process ID from the “PID” column in top , or we can use ps and grep to find it for us, as follows. Obviously, you’ll type the name of your user instead of dave and the name of the process you’re interested in instead of ackermann.

    renice命令将进程的进程ID或PID作为命令行参数。 我们可以从top的“ PID”列中提取进程ID,也可以使用psgrep为我们找到它,如下所示。 显然,您将输入用户名而不是dave ,而不是ackermann来输入您感兴趣的进程的名称。

    ps -eu dave | grep ackermann
    
    ps piped through grep in a terminal window

    Now that we have the PID we can use this with renice. We’re going to set ackermann back to a nicer behavior with a nice value of five. To change the nice value for a running process you must use sudo. Note that there is no “-” on the 5 parameter. You don’t need one for positive numbers and you only need one, not two, for negative numbers.

    现在我们有了PID,可以将它与renice一起使用。 我们将把ackermann设置为一个更好的行为,其值为5。 要更改正在运行的进程的值,必须使用sudo 。 请注意,参数5上没有“-”。 对于正数,您不需要一个,对于负数,您只需要一个,而不是两个。

    sudo renice -n 5 2339
    
    renice command running in a terminal window

    We get confirmation that renice has changed the nice value. It shows us the old value and the new value.

    我们确认renice改变了不错的价格。 它向我们展示了旧价值和新价值。

    The kernel usually does a great job of handling priorities and handing out CPU time and systems resources. But if you have a long, CPU intensive task to run and you don’t care when it concludes, it’ll make your computer run a bit smoother if you set a higher nice value for that task. That will be nicer for everyone.

    内核通常在处理优先级以及分发CPU时间和系统资源方面做得很好。 但是,如果您要执行很长的CPU密集型任务,并且不在乎何时结束,那么如果为该任务设置较高的值,它将使您的计算机运行起来更加流畅。 这对每个人都会更好。

    翻译自: https://www.howtogeek.com/411979/how-to-set-process-priorities-with-the-nice-and-renice-commands-in-linux/

    linux设置进程优先级

    展开全文
  • Linux进程概念——进程优先级和环境变量一、Linux进程优先级1.1 进程优先级三连问?<1> 什么是进程优先级?(优先权 VS 权限)<2> 为什么要有优先级?<3> 怎么使用优先级?1.2 Linux进程优先级...
  • Android进程优先级

    2019-08-05 22:23:31
    进程优先级由高到低排列如下: a. 前台进程 b. 可见进程 c. 服务进程 d. 后台进程 e. 空进程 2.前台进程 前台进程是指正在与用户进行交互的进程,是最高优先级进程,判断为前台进程的因素有以下这些: 1. ...
  • 调节进程优先级

    2014-05-10 15:32:38
    调节进程优先级,能获取权限,锁定优先级,目前DNF能锁定优先级为高,或者实时
  • 本文主要描述的是进程优先级这个概念。从用户空间来看,进程优先级就是nice value和scheduling priority,对应到内核,有静态优先级、realtime优先级、归一化优先级和动态优先级等概念,我们希望能在第二章将这些...
  • Linux 进程优先级

    2019-11-29 20:48:39
    进程优先级 由于系统中进程数量众多, 而CPU资源却较少, 甚至只有一个, 而进程之间需要竞争来使用CPU . 这时让一个比较重要, 需要优先 执行的进程去和众多的其他进程去竞争, 显然是不合理的. 就像感冒患者和有生命...
  • Android | 进程优先级

    2020-03-20 22:27:49
    文章目录进程优先级前台进程可见进程服务进程后台进程空进程 进程优先级 Android系统的进程优先级从高到底分别为: 前台进程 可见进程 服务进程 后台进程 空进程 如下图所示: 下面开始分别介绍这几种进程: ...
  • Linux——进程优先级

    2018-11-09 19:34:33
    进程优先级 概念:cpu资源分配的先后顺序,就是指进程的优先级 优先级高的进程有优先执行的权力。配置进程优先权对多任务环境的linux很有用,可以改善系统性能 还可以把进程运行到指定的cpu上,这样一来,把不...
  • 进程优先级问题ps -le 可以查看到进程优先级的两个决定字段。pri和ni,pri是决定进程优先级的字段,pri = pri+ni,但是pri我们手动改不了,我们可以通过修改ni来间接影响pri,ni修改范围是:-20~19。普通用户只能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 248,517
精华内容 99,406
关键字:

进程优先级