pthread_attr_setinheritsched 设置线程是否继承父线程调度策略
pthread_attr_setschedpolicy 设置线程的调度策略
pthread_attr_setschedparam 设置静态优先级
单位时间相应能力强，里面拥有1-99个静态优先级，数字越大，优先级越高（所谓的优先级指的经过特殊的处理，我们可以让某个人物能够在系统中被更优先的响应，从而分出的从高到低的级别），需要有管理员权限才能启动实时线程
单位时间中，并没有过分的去在乎响应能力的一个线程，里面只有一个静态优先级0，也就是在非实时线程中，它是没有静态优先级的概念的，他的所有的执行过程都是由系统自动分配的
抢占式调度策略跟轮询式调度策略只能在实时线程中被设置，也就是静态优先级1-99的区域内设置，普通非实时线程不能设置
#include <pthread.h>
int pthread_attr_setinheritsched(pthread_attr_t *attr,int inheritsched);#include <pthread.h>
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);#include <pthread.h>
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);struct sched_param {
int sched_priority; /* Scheduling priority */
}#define _GNU_SOURCE //注意这个宏定义不要漏了
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
void *new_thread(void *arg)
{
int retval;
pthread_attr_t myattr;
size_t stack_size;
/*
//这个函数使用后，时灵时不灵，不建议使用
retval = pthread_detach(pthread_self());
if(retval != 0)
{
fprintf(stderr, "设置分离失败：%s\n", strerror(retval));
}
*/
//获取本线程的属性存放到myattr这个变量中
pthread_getattr_np(pthread_self(), &myattr);
//获取线程栈的大小
pthread_attr_getstacksize(&myattr, &stack_size);
printf("stack size = %ld\n", stack_size);
while(1)
{
sleep(1);
printf("in thread\n");
}
return NULL;
}
int main(void)
{
pthread_t tid;
pthread_attr_t attr;
//线程属性初始化
pthread_attr_init(&attr);
//设置线程的属性成为完全分离状态，再也不能用pthread_join来等待这条线程
pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED);
//设置线程的栈大小
pthread_attr_setstacksize(&attr, 16*1024*1024);
//取消行程，后面篇章详细描写
pthread_create(&tid, &attr, new_thread, NULL);
//线程属性销毁
pthread_attr_destroy(&attr);
//线程的属性成为完全分离状态，再也不能用pthread_join来等待这条线程
//pthread_join(tid, NULL);//等待线程退出
return 0;
}
同时改变优先级还需要系统超级用户权限（没有超级用户权限，不给你执行，所以一般情况下很少会设置优先级）
虚拟机设置单核如下>>虚拟机设置=>硬件=>处理器 此处可以设置CPU数量和核数
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <sched.h>
void *start_routine(void *arg)
{
int i, j;
while(1)
{
fprintf(stderr, "%c ", *(char *)arg);
for(i=0; i<100000; i++)
for(j=0; j<1000; j++);
}
pthread_exit(NULL);
}
int main(void)
{
pthread_t tid1, tid2, tid3;
pthread_attr_t attr1, attr2;
struct sched_param param1, param2;
/* 线程属性变量的初始化 */
pthread_attr_init(&attr1);
pthread_attr_init(&attr2);
/* 设置线程是否继承创建者的调度策略 PTHREAD_EXPLICIT_SCHED：不继承才能设置线程的调度策略*/
errno = pthread_attr_setinheritsched(&attr1, PTHREAD_EXPLICIT_SCHED);
if(errno != 0)
{
perror("setinherit failed\n");
return -1;
}
/* 设置线程是否继承创建者的调度策略 PTHREAD_EXPLICIT_SCHED：不继承才能设置线程的调度策略*/
errno = pthread_attr_setinheritsched(&attr2, PTHREAD_EXPLICIT_SCHED);
if(errno != 0)
{
perror("setinherit failed\n");
return -1;
}
/* 设置线程的调度策略：SCHED_FIFO：抢占性调度; SCHED_RR：轮寻式调度；SCHED_OTHER：非实时线程调度策略*/
errno = pthread_attr_setschedpolicy(&attr1, SCHED_RR);
if(errno != 0)
{
perror("setpolicy failed\n");
return -1;
}
errno = pthread_attr_setschedpolicy(&attr2, SCHED_RR);
if(errno != 0)
{
perror("setpolicy failed\n");
return -1;
}
//设置优先级的级别
param1.sched_priority = 1;
param2.sched_priority = 1;
//查看抢占性调度策略的最小跟最大静态优先级的值是多少
printf("min=%d, max=%d\n", sched_get_priority_min(SCHED_FIFO), sched_get_priority_max(SCHED_FIFO));
/* 设置线程静态优先级 */
errno = pthread_attr_setschedparam(&attr1, ¶m1);
if(errno != 0)
{
perror("setparam failed\n");
return -1;
}
errno = pthread_attr_setschedparam(&attr2, ¶m2);
if(errno != 0)
{
perror("setparam failed\n");
return -1;
}
/* 创建三个测试线程 */
/* 线程1，优先级1 */
errno = pthread_create(&tid1, &attr1, start_routine, (void *)"1");
if(errno != 0)
{
perror("create thread 1 failed\n");
return -1;
}
/* 线程2，优先级1 */
errno = pthread_create(&tid2, &attr2, start_routine, (void *)"2");
if(errno != 0)
{
perror("create thread 2 failed\n");
return -1;
}
/* 线程3，非实时线程，静态优先级0 */
errno = pthread_create(&tid3, NULL, start_routine, (void *)"3");
if(errno != 0)
{
perror("create thread 3 failed\n");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_join(tid3, NULL);
pthread_attr_destroy(&attr1);
pthread_attr_destroy(&attr2);
return 0;
}设置抢占性调度结果： SCHED_FIFO
可以看得到，在抢占性调度下，线程2一点资源都没有分配到
设置轮寻式调度结果： SCHED_RR
可以看得到，在轮寻式调度下，线程1和2资源分配很和谐
刚运行CPU就跑满了