线程优先级设置.

新线程默认情况下是继承父线程的调度策略和优先级的.

对属性对象进行初始化时，即调用pthread_attr_init函数初始化时，初始化为默认属性：绑定（PTHREAD_SCOPE_SYSTEM），非分离（PTHREAD_CREATE_JOINABLE），继承父线程调度策略和优先级（PTHREAD_INHERIT_SCHED）.
默认的继承属性是继承父线程的调度策略和优先级，而父线程的调度策略为SCHED_OTHER，优先级为0，所以创建的子线程的调度策略和优先级就继承了父线程的，而不是attr属性指定的。如果把attr里的继承属性改为PTHREAD_EXPLICIT_SCHED，该属性表示新的子线程的调度策略和优先级由自己指定，不继承父线程，那么新建的子线程的调度策略和优先级就是指定的了.

 

线程的调度策略分为3个：SCHED_OTHER，SCHED_FIFO，SCHED_RR。SCHED_OTHER是非实时分时调度策略，线程优先级为0；SCHED_FIFO是实时先进先出调度策略，即一当占用CPU，除非自己阻塞或结束或有更高优先级线程，否则会一直运行，线程优先级为1－99；SCHED_RR是实时分时调度策略，其不会一直占用CPU，运行一个时间片后会让出CPU给自己同优先级的线程；实时调度策略会抢占非实时调度策略.

默认属性创建的线程,其调度策略是SCHED_OTHER,优先级为0.

欲改变新创建线程的调度属性和优先级,则可遵从以下几个步骤来设置.

1. 调用pthread_attr_init来对属性attr进行初始化.

2. 调用pthread_attr_setinheritsched来设置子线程attr属性的继承属性为PTHREAD_EXPLICIT_SCHED,使新线程可自己指定调度策略和优先级.

3. 调用pthread_attr_setschedpolicy来设置新线程的调度策略.

4.调用pthread_attr_setschedparam来设置新线程的优先级.

5. 调用pthread_create创建新线程.

6. 新线程创建完毕后,调用pthread_attr_destroy销毁attr.

 

实例如下:
#include
#include
#include
#include
#include
#include


void *pthread1(void *argv)
{
    volatile int i = 0,ret,policy;
    struct sched_param param;
    //获取线程调度参数
    ret = pthread_getschedparam(pthread_self(), &policy, ¶m);
    if(ret!=0)
    {
    printf("pthread_getschedparam %s\n", strerror(ret) );
    exit(1);
    }
    if (policy == SCHED_FIFO)
    {
    printf("policy:SCHED_FIFO\n");
    }
    else if (policy == SCHED_OTHER)
    {
    printf("policy:SCHED_OTHER\n");
    }
    else if (policy == SCHED_RR)
    {
    printf("policy:SCHED_RR\n");
    }
    printf("param:%d\n", param.sched_priority);


    return;
    while(1)
    {
        ;
    }

}

void *pthread2(void *argv)
{
    volatile int i = 0,ret,policy;


struct sched_param param;
//获取线程调度参数
ret = pthread_getschedparam(pthread_self(), &policy, ¶m);
if(ret!=0)
{
printf("pthread_getschedparam %s\n", strerror(ret) );
exit(1);
}
if (policy == SCHED_FIFO)
{
printf("policy:SCHED_FIFO\n");
}
else if (policy == SCHED_OTHER)
{
printf("policy:SCHED_OTHER\n");
}
else if (policy == SCHED_RR)
{
printf("policy:SCHED_RR\n");
}
printf("param:%d\n", param.sched_priority);

   return;
    while(1)
    {
        printf("rrrrrrrrrrrrrrrrrr\r\n");
    }
}

int main(void)
{
    int err = 0;
    int pthread_policy;
    struct sched_param sch,sch1;
    pthread_attr_t attr,attr1;
    pthread_t pthread_id1, pthread_id2;
    int inher = PTHREAD_EXPLICIT_SCHED;


   
    pthread_attr_init(&attr);
    err = pthread_attr_setinheritsched(&attr, inher);
    err = pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM);
    pthread_attr_getschedparam(&attr,&sch);
    err = pthread_attr_getschedpolicy(&attr,&pthread_policy);
    if ( err != 0)
    {
        printf("[%s][%d]get policy fail\r\n",__FUNCTION__,__LINE__);
        return -1;
    }
   
    pthread_attr_setschedpolicy(&attr,SCHED_FIFO);
    sch.sched_priority = 99;
   
    pthread_attr_setschedparam(&attr,&sch);
   
   
    pthread_attr_init(&attr1);
    err = pthread_attr_setinheritsched(&attr1, inher);
    pthread_attr_getschedparam(&attr1,&sch1);
    err = pthread_attr_getschedpolicy(&attr1,&pthread_policy);
    if ( err != 0)
    {
        printf("[%s][%d]get policy fail\r\n",__FUNCTION__,__LINE__);
        return -1;
    }
   

    pthread_attr_setschedpolicy(&attr1,SCHED_FIFO);
    sch1.sched_priority = 1;
   
    pthread_attr_setschedparam(&attr1,&sch1);
            
    err = pthread_create(&pthread_id1, &attr, pthread1, NULL);
    if(err < 0)
    {
        return -1;
    }
    pthread_attr_destroy(&attr);

    err = pthread_create(&pthread_id2, &attr1, pthread2, NULL);
    if(err < 0)
    {
        return -1;
    }
    pthread_attr_destroy(&attr1);

    /* 等待线程结束 */
    pthread_join(pthread_id1, NULL);
    pthread_join(pthread_id2, NULL);
    exit(0);
}