get＿thread＿info（thread＿index）；
   long num ＝ 0；
   for （int i ＝ 0； i ＜ 10； i＋＋）
   ｛
       for （int j ＝ 0； j ＜ 5000000； j＋＋）
       ｛
           ／／ 没什么意义，纯粹是模拟 CPU 密集计算。
           float f1 ＝ （（i＋1） ＊ 345．45） ＊ 12．3 ＊ 45．6 ／ 78．9 ／ （（j＋1） ＊ 4567．89）；
           float f2 ＝ （i＋1） ＊ 12．3 ＊ 45．6 ／ 78．9 ＊ （j＋1）；
           float f3 ＝ f1 ／ f2；
       ｝
       ／／ 打印计数信息，为了能看到某个线程正在执行
       printf（＂thread＿index ％d： num ＝ ％ld ＂， thread＿index， num＋＋）；
   ｝
   ／／ 线程执行结束
   printf（＂thread＿index ％d： exit ＂， thread＿index）；
   return 0；
｝
void main（void）
｛
   ／／ 一共创建四个线程：0和1－实时线程，2和3－普通线程（非实时）
   int thread＿num ＝ 4；
   ／／ 分配的线程索引号，会传递给线程参数
   int index［4］ ＝ ｛1， 2， 3， 4｝；
   ／／ 用来保存 4 个线程的 id 号
   pthread＿t ppid［4］；
   ／／ 用来设置 2 个实时线程的属性：调度策略和优先级
   pthread＿attr＿t attr［2］；
   struct sched＿param param［2］；
   ／／ 实时线程，必须由 root 用户才能创建
   if （0 ！＝ getuid（））
   ｛
       printf（＂Please run as root ＂）；
       exit（0）；
   ｝
   ／／ 创建 4 个线程
   for （int i ＝ 0； i ＜ thread＿num； i＋＋）
   ｛
       if （i ＜＝ 1）    ／／ 前2个创建实时线程
       ｛
           ／／ 初始化线程属性
           pthread＿attr＿init（＆attr［i］）；
           ／／ 设置调度策略为：SCHED＿FIFO
           pthread＿attr＿setschedpolicy（＆attr［i］， SCHED＿FIFO）；
           ／／ 设置优先级为 51，52。
           param［i］．＿＿sched＿priority ＝ 51 ＋ i；
           pthread＿attr＿setschedparam（＆attr［i］， ＆param［i］）；
           ／／ 设置线程属性：不要继承 main 线程的调度策略和优先级。
           pthread＿attr＿setinheritsched（＆attr［i］， PTHREAD＿EXPLICIT＿SCHED）；
           ／／ 创建线程
           pthread＿create（＆ppid［i］， ＆attr［i］，（void ＊）thread＿routine， （void ＊）＆index［i］）；
       ｝
       else        ／／ 后两个创建普通线程
       ｛
           pthread＿create（＆ppid［i］， 0， （void ＊）thread＿routine， （void ＊）＆index［i］）；
       ｝
   ｝
   ／／ 等待 4 个线程执行结束
   for （int i ＝ 0； i ＜ 4； i＋＋）
       pthread＿join（ppid［i］， 0）；
   for （int i ＝ 0； i ＜ 2； i＋＋）
       pthread＿attr＿destroy（＆attr［i］）；
｝

编译成可执行程序的指令：

gcc －o test test．c －lpthread

脑残测试开始

首先说一下预期结果，如果没有预期结果，那其他任何问题都压根不用谈了。

一共有 4 个线程：

线程索引号 1和2：是实时线程（调度策略是 SCHED＿FIFO，优先级是 51，52）；

线程索引号 3和4：是普通线程（调度策略是 SCHED＿OTHER， 优先级是 0）；

我的测试环境是：Ubuntu16．04，是一台安装在 Windows10 上面的虚拟机。

我期望的结果是：

首先打印 1 号和 2 号这两个线程的信息，因为它俩是实时任务，需要优先被调度；

1 号线程的优先级是 51，小于 2 号线程的优先级 52，因此应该是 2 号线程结束之后，才轮到 1 号线程执行；

3 号和 4 号线程是普通进程，它俩需要等到 1 号和 2 号线程全部执行结束之后才开始执行，并且 3 号和 4 号线程应该是交替执行，因为它俩的调度策略和优先级都是一样的。

我满怀希望的在工作电脑中测试，打印结果如下：

＝＝＝＝＞ thread＿index ＝ 4
thread＿index 4： SCHED＿OTHER
thread＿index 4： priority ＝ 0
＝＝＝＝＞ thread＿index ＝ 1
thread＿index 1： SCHED＿FIFO
thread＿index 1： priority ＝ 51
＝＝＝＝＞ thread＿index ＝ 2
thread＿index 2： SCHED＿FIFO
thread＿index 2： priority ＝ 52
thread＿index 2： num ＝ 0
thread＿index 4： num ＝ 0
＝＝＝＝＞ thread＿index ＝ 3
thread＿index 3： SCHED＿OTHER
thread＿index 3： priority ＝ 0
thread＿index 1： num ＝ 0
thread＿index 2： num ＝ 1
thread＿index 4： num ＝ 1
thread＿index 3： num ＝ 0
thread＿index 1： num ＝ 1
thread＿index 2： num ＝ 2
thread＿index 4： num ＝ 2
thread＿index 3： num ＝ 1

后面打印内容不用输出了，因为前面已经出现了问题。