精华内容
下载资源
问答
  • Linux线程调度

    2015-03-17 22:44:10
    由于Linux线程实现的一些特殊性,所以会给我们理解线程及其相关的一些函数带来疑惑,这里做个解答:  1、关于sleep  很多书籍上都说sleep这个系统调用会使整个进程sleep,而不单是sleep一个线程。这样说没...
    由于Linux对线程实现的一些特殊性,所以会给我们理解线程及其相关的一些函数带来疑惑,这里做个解答: 

    1、关于sleep 

    很多书籍上都说sleep这个系统调用会使整个进程sleep,而不单是sleep一个线程。这样说没错,但我们要是在Linux下写一个多线程 的程序,在一个线程中调用sleep,你会发现其他线程照样运行,这是怎么回事呢?这就是由于Linux下的线程,其实线程的注册、销毁等工作是在 pthread库里面,而在内核中,线程其实就是一个进程。Linux对线程的实现是通过__clone调用实现的,这个调用会new多个进程出来,只不 过的是, Linux会设置这些进程的共享内存空间、文件描述符等属性为相同,这样就实现了线程的定义(共享一个进程的内存空间、线程切换不需要切换上下文环 境......)。所以,很多书籍上会说Linux的线程在核内是轻量级的进程,就是这个道理。因为和普通进程相比,Linux的线程在核内就是一些被设 置了很多属性的进程,从而实现了线程。 

    所以,在Linux下,一个线程调用了sleep,反映到核内就是sleep了一个轻量级进程,自然其他的线程(核内的轻量级进程)不受影响,照 样可以run了。简言之,之所以sleep一个线程,其他线程仍然可以执行,这是因为在Linux下,线程和进程不是n对1的,而是1对1的。 

    2、有关线程的调度 

    有了1的描述,我们就清楚的知道了,其实Linux对线程的调度,策略和进程是基本一致的。所以,很多人问,为什么一个线程中如果有一个循环的 话,其他线程都得不到执行,这就是因为Linux对线程的调度,策略和进程是一样的,即,如果一个线程处于一个高密度的工作状态的话,或者该线程的cpu slice没用完的话,这个线程是不会被调度的。有关这个问题,还可以参看本论坛中“有关线程切换的一个问题”一帖。 

    其实说白了,明白了第一点的话,很多Linux线程的问题就迎刃而解了。


    有关Linux下线程的实现方式,再附上一段“POSIX线程编程指南”(来自IBM Developworks)中的描述,这段描述很专业,很到位: 

    我们知道,Linux的线程实现是在核外进行的,核内提供的是创建进程的接口do_fork()。内核提供了两个系统调用__clone()和 fork (),最终都用不同的参数调用do_fork()核内API。当然,要想实现线程,没有核心对多进程(其实是轻量级进程)共享数据段的支持是不行的,因 此,do_fork()提供了很多参数,包括CLONE_VM(共享内存空间)、CLONE_FS(共享文件系统信息)、CLONE_FILES(共享文 件描述符表)、CLONE_SIGHAND(共享信号句柄表)和CLONE_PID(共享进程ID,仅对核内进程,即0号进程有效)。当使用fork系统 调用时,内核调用do_fork()不使用任何共享属性,进程拥有独立的运行环境,而使用pthread_create()来创建线程时,则最终设置了所 有这些属性来调用__clone(),而这些参数又全部传给核内的do_fork(),从而创建的"进程"拥有共享的运行环境,只有栈是独立的,由 __clone()传入。 

    Linux线程在核内是以轻量级进程的形式存在的,拥有独立的进程表项,而所有的创建、同步、删除等操作都在核外 pthread库中进行。pthread库使用一个管理线程(__pthread_manager(),每个进程独立且唯一)来管理线程的创建和终止,为 线程分配线程ID,发送线程相关的信号(比如Cancel),而主线程(pthread_create())的调用者则通过管道将请求信息传给管理线程。
    展开全文
  • 基于加权平均PIP的Linux线程调度方法研究.pdf
  • Linux线程调度方式通过线程属性设置

    千次阅读 2018-02-25 22:13:08
    Linux 线程调度方式 在创建线程的时候,我们可以指定所要创建线程的属性,属性中有线程的“调度方式”,线程的调度方式有三种: SCHED_OTHER:分时调度策略 根据nice指来确定线程的运行的顺序(counter+20-nice ...

    Linux 线程调度方式

    在创建线程的时候,我们可以指定所要创建线程的属性,属性中有线程的“调度方式”,线程的调度方式有三种:

    • SCHED_OTHER:分时调度策略
      根据nice指来确定线程的运行的顺序(counter+20-nice 值越大,如果当前没有任务在运行,则从就绪队列里找一个这个值最大的线程运行)。nice越小,counter越大。当时间片用完之后或者线程主动交出cpu调度程序才会运行。然后把这个任务放到就绪队列的尾部或者等待队列。重新在就绪队列里找一个(counter+20-nice)最大的线程运行。分时调度策略里是没有优先级的。只有一个类似优先级的概念是(counter+20-nice)。没有优先级,所以没有抢占。

    • SCHED_FIFO:实时调度策略
      先到先服务。一旦占用cpu则一直运行直到有更高优先级任务到达或者自己主动放弃。任务结束后也是放到就绪任务队列的尾部,为了保持相同优先级的任务公平调度。

    • SCHED_RR实时调度策略:

      时间片轮转。从就绪队列里找优先级最高任务执行,当进程时间片用完或者线程主动交出cpu,调度程序才会运行,并置于就绪队列尾或者等待队列中。然后系统在就绪队列里找优先级最高的任务执行。放在对列尾保证了所有具有相同优先级的RR任务的调度公平。

    比较SCHED_FIFO 和 SCHED_RR两种实时调度策略:

    两者唯一的区别在于采取中两种调度策略的线程最大占用cpu时间的长度不同。

    采取SCHED_FIFO调度策略的正在运行的线程释放cpu的情况有:

    • 就绪队列里有更高优先级的线程
    • 当前线程主动释放cpu(等待其他的资源)

    可见,采取SCHED_FIFO调度策略的线程可能会一直占用着cpu。

    采取SCHED_RR调度策略的正在运行的线程释放cpu的情况有:

    • 分配给当前线程的时间片用完了
    • 就绪队列里有更高优先级的线程
    • 当前线程主动释放cpu(等待其他的资源)

    可见,采取SCHED_RR调度策略的线程占用cpu的时间不会超过分配给它的时间片长度。

    展开全文
  • 浅析Linux线程调度

    万次阅读 2014-12-20 13:47:22
    Linux这样实现的线程的好处的之一是:线程调度直接使用进程调度就可以了,没必要再搞一个进程内的线程调度器。在Linux中,调度器是基于线程的调度策略(scheduling policy)和静态调度优先级(st

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

        对于下面三种调度策略SCHED_OTHER, SCHED_IDLE, SCHED_BATCH,其调度优先级sched_priority是不起作用的,即可以看成其调度优先级为0;调度策略SCHED_FIFOSCHED_RR是实时策略,他们的调度值范围是199,数值越大优先级越高,另外实时调度策略的线程总是比前面三种通常的调度策略优先级更高。通常,调度器会为每个可能的调度优先级(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,默认值为0nice值越大则优先级越低,相比高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中,与调度相关的常见接口如下:

    #include <sched.h>
    int sched_get_priority_max(int policy);

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

    #include <pthread.h>
    int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

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

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

    获取线程的调度策略。

    #include <pthread.h>
    int pthread_attr_setschedparam(pthread_attr_t *attr,
    const struct sched_param *param);

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

    struct sched_param {
       int sched_priority;     /* Scheduling priority */
    };

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

    int pthread_attr_getschedparam(const pthread_attr_t *attr,
                                          struct sched_param *param);
    #include <sched.h>
    int sched_yield(void);

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

    #include <sched.h>
    int sched_setaffinity(pid_t pid, 
                          size_t cpusetsize,const cpu_set_t *mask);

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

    #include <pthread.h>
    int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize,
                                      const cpu_set_t *cpuset);
    int pthread_attr_setaffinity_np(pthread_attr_t *attr,
    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,回车后,回到刚才界面,此时显示此进程使用哪个CPU。

        下面是测试代码:

    #include <stdio.h>
    #include <pthread.h>
    #include <sched.h>
    #include <assert.h>
    
    static int get_thread_policy(pthread_attr_t *attr)
    {
        int policy;
        int rs = pthread_attr_getschedpolicy(attr,&policy);
        assert(rs==0);
    
        switch(policy)
        {   
            case SCHED_FIFO:
                printf("policy=SCHED_FIFO\n");
                break;
    
            case SCHED_RR:
                printf("policy=SCHED_RR\n");
                break;
    
            case SCHED_OTHER:
                printf("policy=SCHED_OTHER\n");
                break;
    
            default:
                printf("policy=UNKNOWN\n");
                break;
        }   
        return policy;
    }
    
    static void show_thread_priority(pthread_attr_t *attr,int policy)
    {
        int priority = sched_get_priority_max(policy);
        assert(priority != -1);
        printf("max_priority=%d\n",priority);
    
        priority= sched_get_priority_min(policy);
        assert(priority != -1);
        printf("min_priority=%d\n",priority);
    }
    
    static int get_thread_priority(pthread_attr_t *attr)
    {
        struct sched_param param;
        int rs = pthread_attr_getschedparam(attr,¶m);
        assert(rs == 0);
    
        printf("priority=%d\n",param.__sched_priority);
        return param.__sched_priority;
    }
    
    static void set_thread_policy(pthread_attr_t *attr,int policy)
    {
        int rs = pthread_attr_setschedpolicy(attr,policy);
        assert(rs==0);
    }
    
    int main(void)
    {
        pthread_attr_t attr;
        int rs;
    
        rs = pthread_attr_init(&attr);
        assert(rs==0);
    
        int policy = get_thread_policy(&attr);
    
        printf("Show current configuration of priority\n");
        get_thread_policy(&attr);
        show_thread_priority(&attr,policy);
    
        printf("show SCHED_FIFO of priority\n");
        show_thread_priority(&attr,SCHED_FIFO);
    
        printf("show SCHED_RR of priority\n");
        show_thread_priority(&attr,SCHED_RR);
    
        printf("show priority of current thread\n");
        get_thread_priority(&attr);
    
        printf("Set thread policy\n");
    
        printf("set SCHED_FIFO policy\n");
        set_thread_policy(&attr,SCHED_FIFO);
        get_thread_policy(&attr);
        get_thread_priority(&attr);
    
        printf("set SCHED_RR policy\n");
        set_thread_policy(&attr,SCHED_RR);
        get_thread_policy(&attr);
    
        printf("Restore current policy\n");
        set_thread_policy(&attr,policy);
        get_thread_priority(&attr);
    
        rs = pthread_attr_destroy(&attr);
        assert(rs==0);
    
        return 0;
    }

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

    $gcc -Wall -lpthread hack_thread_sched.c -o hack_thread_sched
    $./hack_thread_sched 
    policy=SCHED_OTHER
    Show current configuration of priority
    policy=SCHED_OTHER
    max_priority=0
    min_priority=0
    show SCHED_FIFO of priority
    max_priority=99
    min_priority=1
    show SCHED_RR of priority
    max_priority=99
    min_priority=1
    show priority of current thread
    priority=0
    Set thread policy
    set SCHED_FIFO policy
    policy=SCHED_FIFO
    priority=0
    set SCHED_RR policy
    policy=SCHED_RR
    Restore current policy
    priority=0

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

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

        II)调度策略SCHED_FIFOSCHED_RR的优先级范围为199,并且初始设置时对应的调度优先级初始值为0。

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

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

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

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

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

    参考资料

    http://man7.org/linux/man-pages/man7/sched.7.html
    http://man7.org/linux/man-pages/man2/sched_getaffinity.2.html
    http://www.cnblogs.com/xiaotlili/p/3510224.html
    http://www.708luo.com/?p=78 Linux
    http://www.quora.com/What-is-the-difference-between-the-NI-and-PR-values-in-the-top-1-commands-output
    http://blog.csdn.net/hanchaoman/article/details/6697636
    http://www.ibm.com/developerworks/cn/linux/l-affinity.html
    http://blog.csdn.net/chenggong2dm/article/details/6131052

    《Linux内核设计与实现》(第3版)
    《深入分析Linux内核源代码》(陈莉君著)





    展开全文
  • 总结:对三种线程调度方式进行测试。 1.SCHED_OTHER:分时调度策略,为默认方式,凡是采用本模式的线程,线程优先级会强制为0,通俗点将,工作在本模式下的线程,都在同一优先级下。所谓的“分时调度策略”,可以...

    总结:对三种线程调度方式进行测试。

    1.SCHED_OTHER:分时调度策略,为默认方式,凡是采用本模式的线程,线程优先级会强制为0,通俗点将,工作在本模式下的线程,都在同一优先级下。所谓的“分时调度策略”,可以理解为线程执行一次后主动放弃CPU,线程调度一次,执行下一个线程。测试代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <pthread.h>
    #include <sched.h>
    #include <assert.h>

    void *Thread1(void* pp)
    {
      sleep(1);
      int i,j;
      int policy;
      struct sched_param param;
      pthread_getschedparam(pthread_self(),&policy,&param);
      if(policy == SCHED_OTHER) printf("SCHED_OTHER 1\n");
      if(policy == SCHED_RR)  printf("SCHED_RR 1 \n");
      if(policy==SCHED_FIFO)  printf("SCHED_FIFO 1\n");

      //for(i=1;i<1000;i++)  
      while(1)
      {
      i++;
        for(j=1;j<5000000;j++)
        {
        }
        //printf("t1-%d", i);
        printf("1");
        if(i%100 == 0) printf("\n");
      }
      printf("Pthread 1 exit\n");
    }

    void *Thread2(void* pp)
    {
      sleep(1);
      int i,j,m;
      int policy;
      struct sched_param param;
    pthread_getschedparam(pthread_self(),&policy,&param);
     if(policy == SCHED_OTHER) printf("SCHED_OTHER 2\n");
      if(policy == SCHED_RR)  printf("SCHED_RR 2\n");
      if(policy==SCHED_FIFO)  printf("SCHED_FIFO 2\n");

      //for(i=1;i<1000;i++)
      while(1)
      {
      i++;
        for(j=1;j<5000000;j++)
        {
          
        }
        //printf("t2-%d", i);
        printf("2");
        if(i%100 == 0) printf("\n");
      }
      printf("Pthread 2 exit\n");
    }

    void *Thread3(void* pp)
    {
      sleep(1);
      int i,j;
      int policy;
      struct sched_param param;
    pthread_getschedparam(pthread_self(),&policy,&param);
     if(policy == SCHED_OTHER) printf("SCHED_OTHER 3\n");
      if(policy == SCHED_RR) printf("SCHED_RR 3\n");
      if(policy==SCHED_FIFO) printf("SCHED_FIFO 3\n");

      //for(i=1;i<1000;i++)
      while(1)
      {
        i++;
        for(j=1;j<5000000;j++)
        {
        }
        //printf("t3-%d", i);
        printf("3");
        if(i%100 == 0) printf("\n");
      }
      printf("Pthread 3 exit\n");
    }

    int main()
    {
        int i;
        i = getuid();
        if(i==0)
            printf("The current user is root\n");
        else
            printf("The current user is not root\n");

        pthread_t ppid1,ppid2,ppid3;
        struct sched_param param;

        pthread_attr_t attr1,attr2,attr3;

        pthread_attr_init(&attr1);
        pthread_attr_init(&attr2);
        pthread_attr_init(&attr3);
        
    #if 0        
        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr1,SCHED_RR);
        pthread_attr_setschedparam(&attr1,&param);
        pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr2,SCHED_RR);
        pthread_attr_setschedparam(&attr2,&param);
        pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr3,SCHED_RR);
        pthread_attr_setschedparam(&attr3,&param);
        pthread_attr_setinheritsched(&attr3,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话
    #endif

        pthread_create(&ppid1,&attr1,Thread1,NULL);
        pthread_create(&ppid2,&attr2,Thread2,NULL);
        pthread_create(&ppid3,&attr3,Thread3,NULL);

        pthread_join(ppid1,NULL);
        pthread_join(ppid2,NULL);
        pthread_join(ppid3,NULL);    
        while(1) {           
            sleep(100);
            printf("main loop\n");
        }
        
        pthread_attr_destroy(&attr1);
        pthread_attr_destroy(&attr2);
        pthread_attr_destroy(&attr3);
        return 0;
    }

    测试结果如下,每个线程执行一次就进行一次线程调度。

    2.SCHED_FIFO:实时调度策略,先到先服务(优先级和启动顺序,优先级高的先到,同一优先级下,先创建的线程先到)。

       线程优先级不同:优先级高的线程永远占据CPU,不进行调度。除非主动放弃CPU(线程挂起、休眠等);

       线程优先级相同:最先启动的线程永远占据CPU,不进行调度。除非主动放弃CPU(线程挂起、休眠等);

    #if 1        
        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr1,SCHED_FIFO);
        pthread_attr_setschedparam(&attr1,&param);
        pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr2,SCHED_FIFO);
        pthread_attr_setschedparam(&attr2,&param);
        pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr3,SCHED_FIFO);
        pthread_attr_setschedparam(&attr3,&param);
        pthread_attr_setinheritsched(&attr3,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话
    #endif

    3.SCHED_RR:实实时调度策略,时间片轮转。当线程的时间片用完,系统将重新分配时间片,并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平;

     线程优先级不同:优先级高的线程永远占据CPU,不进行调度。除非主动放弃CPU(线程挂起、休眠等);

     线程优先级相同:每个线程执行一段时间(时间片),时间到了之后。线程调度,执行一下个排队线程;

    #if 1        
        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr1,SCHED_RR);
        pthread_attr_setschedparam(&attr1,&param);
        pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr2,SCHED_RR);
        pthread_attr_setschedparam(&attr2,&param);
        pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话

        param.sched_priority = 10;
        pthread_attr_setschedpolicy(&attr3,SCHED_RR);
        pthread_attr_setschedparam(&attr3,&param);
        pthread_attr_setinheritsched(&attr3,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话
    #endif

     

     

     

    展开全文
  • 依赖的是中断机制,通过中断抢回CPU执行权限然后进行调度,如Linux内核对线程调度。 协作式调度。需要主动让出CPU,调用调度代码进行调度,如协程,没有中断机制一般无法真正做到抢占。 Linux NPTL 线程库 看...
  • linux线程调度策略

    千次阅读 2014-04-19 16:48:39
    linux进程调度方法(SCHED_OTHER,SCHED_FIFO,SCHED_RR)  linux内核的三种调度方法: 1,SCHED_OTHER 分时调度策略, 2,SCHED_FIFO实时调度策略,先到先服务 3,SCHED_RR实时调度策略,时间片轮
  • Linux 线程调度与优先级设置

    千次阅读 2017-03-17 18:47:56
    线程调度间的上下文切换 什么是上下文切换? 如果主线程是唯一的线程,那么他基本上不会被调度出去。另一方面,如果可运行的线程数大于CPU的数量,那么操作系统最终会将某个正在运行的线程调度出去,从而 使其他线程...
  • 多线程之linux线程调度策略

    千次阅读 2015-03-21 21:35:40
    linux线程调度策略分为3个:SCHED_OTHER,SCHED_FIFO,SCHED_RR  讲策略之前,大家需要理解实时与非实时之分。实时就是指操作系统对一些中断等的响应时效性非常高,即使是在内核态的时候,非实时反之。目前像...
  • 1.调度策略和优先级 1.1.调度策略 sched.h文件中定义了几种调度策略 /* Scheduling algorithms. */ #define SCHED_OTHER 0 #define SCHED_FIFO 1...通过pthread_create创建,但属性参数传递NULL创建的线程默认以SC...
  • pthread_setschedparam()是修改现在正在执行中的线程,具体地说,就是在pthread_create之后才能使用。 pthread_attr_setschedparam是修改将要创建的线程的参数,在pthread_create就要使用了。
  • linux线程调度策略(转)

    千次阅读 2016-06-28 17:38:27
    操作系统通过任务调度算法快速切换线程来模拟多线程并行,交替地停止一个线程,然后切换到另外一个上运行。支持任务优先级,高优先级线程比低优先级线程更先执行,也就是说低优先线程必须等到高
  • 嵌入式 linux线程调度方式小结

    千次阅读 2014-02-23 16:35:34
    linux进程调度方法(SCHED_OTHER,SCHED_FIFO,SCHED_RR) linux进程调度方法(SCHED_OTHER,SCHED_FIFO,SCHED_RR) linux内核的三种调度方法: 1,SCHED_OTHER 分时调度策略, 2,SCHED_FIFO实时调度策略,先到先...
  • 上一篇文章介绍了Linux下的调度策略和优先级,在Ubuntu09.10上的一些特性,这里测试一下其中的两种特性,SCHED_OTHER和SCHED_RR,还有就是优先级的问题,是不是能够保证,高优先级的线程,就可以保证先运行。...
  • Linux线程调度机制

    千次阅读 2019-01-10 21:32:49
    Linux线程的调度机制  在Linux中,线程是由进程来实现,线程就是轻量级进程( lightweight process ),因此在Linux中,线程的调度是按照进程的调度方式来进行调度的。Linux这样实现的线程的好处的之一是:线程调度...
  • linux线程调度

    千次阅读 2018-11-03 10:44:56
    linux的进程和线程是有点奇怪的,分为内核线程、用户进程和用户线程,这里分类...但是一般的开发者是不会自己实现线程调度器的,他们一般使用成熟的线程库,由线程库中的负责线程的创建和调度。操作系统会把用户进程...
  • linux rt 线程调度

    2019-07-18 00:37:21
    最近遇到问题需要trace某个rt线程调度情况 trace event filter: echo 1 > sched/sched_switch/enable echo "next_comm == xxx" >sched/sched_switch/filter (filter 格式可以cat format 同目录下获得) echo...
  •  Linux线程调度策略分为3个:SCHED_OTHER,SCHED_FIFO,SCHED_RR  讲策略之前,大家需要理解实时与非实时之分。实时就是指操作系统对一些中断等的响应时效性非常高,即使是在内核态的时候,非实时反
  • 首先,Linux是一个时分操作系统...linux线程优先级的范围是 0 ~ 139,值越小,优先级越高。user space 线程优先级的范围是 100 ~ 139,默认创建的线程优先级是120,对应的nice值是0,nice值的范围是 -20 ~ 19,对应的优
  • Linux线程调度策略

    千次阅读 2018-07-09 11:01:22
    转自:http://blog.csdn.net/byperseverance/article/details/44522731 Linux线程调度策略分为3个:SCHED_OTHER,SCHED_FIFO,SCHED_RR 讲策略之前,大家需要理解实时与非实时之分。实时就是指操作系统对一些...
  • 最近接触到关于linux调度的一些相关内容,这里做个总结笔记。这里主要学习到三种调度策略,SCHED_RR,SCHED_FIFO,SCHED_OTHER这三种。具体详细的内容就不多说,已经有很多详细的介绍了。这里记录下怎么查看某个进程...
  • linux多线程学习设置线程调度权限

    千次阅读 2015-04-10 18:26:05
    pthread_setschedparam 设置线程的权限 int pthread_setschedparam(pthread_t target_thread, int policy, const struct sched_param *param) 参数 1. target_thread是使用...线程调度有三种策略:SCHED_OT
  • 今天先借胆来谈一下Linux下的线程调度策略 PS: 以下解析的Linux kernel版本号为4.19.25 Thread schedule Motivation 首先,为什么要有线程调度这种东西 主要是因为人民日益增长的CPU需求和同落后的I/O速度之间的...
  • 关于linux c 多线程调度执行顺序

    千次阅读 2017-12-20 09:54:52
    最近在学习linux 下c语言的多线程调度,在博主李亚超的文章Linux C 多线程执行顺序问题(原链接:http://blog.csdn.net/harry_lyc/article/details/6055734#reply)一文中的下面回复有人探讨到线程之间是通过时间片...
  • 基于Linux环境日志服务器的线程调度问题.pdf
  • Intel公司的超线程技术(Hyper-ThreadingTechnology)是一项新的微处理器体系结构技术,...分析了超线程技术的特点,重点研究了Linux线程感知调度优化技术,解决了对Intel处理器的有效支持问题,并且进行了相关的性能评测。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,898
精华内容 44,759
关键字:

linux线程调度

linux 订阅