由于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()）的调用者则通过管道将请求信息传给管理线程。

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中，线程是由进程来实现，线程就是轻量级进程（ 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中，与调度相关的常见接口如下：
 
 
#include <sched.h>
int sched_get_priority_max(int policy);
 
 
该接口获取指定调度策略可以设置的最大优先级，类似的 sched_get_priority_min接口获取调度策略可以设置的最小优先级。在Linux中，对于SCHED_FIFO和SCHED_RR调度策略其优先级为1到99，其他调度策略优先级为0。注意在不同系统上，这个优先级范围可能不一样。
 
 
#include <pthread.h>
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)
 
 
获取线程的调度策略。
 
 
#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，若pid为0，则设置的是调用线程的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，回车后，回到刚才界面，此时P 显示此进程使用哪个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_FIFO和SCHED_RR的优先级范围为1到99，并且初始设置时对应的调度优先级初始值为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，通俗点将，工作在本模式下的线程，都在同一优先级下。所谓的“分时调度策略”，可以理解为线程执行一次后主动放弃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