linux 下设置线程优先级
原文链接：http://www.cnblogs.com/xiaotlili/p/3510224.html
root@ubuntu:tmp# cat test2.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>  


void Thread1()
{
  printf("t1\n");
  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<10;i++)
  {
    for(j=1;j<5000000;j++)
    {
    }
    printf("thread 1\n");
  }
  printf("Pthread 1 exit\n");
}

void Thread2()
{
  printf("t2\n");
  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<10;i++)
  {
    for(j=1;j<5000000;j++)
    {
      
    }
    printf("thread 2\n");
  }
  printf("Pthread 2 exit\n");
}

void Thread3()
{
  printf("t3\n");
  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<10;i++)
  {
    for(j=1;j<5000000;j++)
    {
    }
    printf("thread 3\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 attr,attr1,attr2;
  
  pthread_attr_init(&attr1);
  pthread_attr_init(&attr);
  pthread_attr_init(&attr2);
  param.sched_priority = 51;
  pthread_attr_setschedpolicy(&attr2,SCHED_RR);
  pthread_attr_setschedparam(&attr2,&param);
  pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话

  param.sched_priority = 21;
  pthread_attr_setschedpolicy(&attr1,SCHED_RR);
  pthread_attr_setschedparam(&attr1,&param);
  pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);
 
  pthread_create(&ppid3,&attr,(void *)Thread3,NULL);
  pthread_create(&ppid2,&attr1,(void *)Thread2,NULL);
  pthread_create(&ppid1,&attr2,(void *)Thread1,NULL);
 
  pthread_join(ppid3,NULL);
  pthread_join(ppid2,NULL);
  pthread_join(ppid1,NULL);
  pthread_attr_destroy(&attr2);
  pthread_attr_destroy(&attr1);
  return 0;
}


运行一下
gcc -o test2 test2.c -lpthread
The current user is root
t2
t3
t1
SCHED_OTHER 3
SCHED_RR 1 
SCHED_RR 2
thread 1
thread 3
thread 2
thread 1
thread 3
thread 2
thread 1
thread 2
thread 3
thread 1
thread 2
thread 3
thread 1
thread 2
thread 3
thread 1
thread 2
thread 3
thread 1
thread 3
thread 1
thread 2
thread 3
thread 1
Pthread 1 exit
thread 2
thread 3
Pthread 3 exit
thread 2
Pthread 2 exit


再跑一次，其实结果会变
root@ubuntu:tmp# ./test2
The current user is root
t3
t1
t2
SCHED_RR 1 
SCHED_RR 2
thread 1
thread 2
thread 2
thread 1
thread 2
thread 1
thread 2
thread 1
thread 2
thread 1
thread 2
thread 1
thread 2
thread 1
thread 1
thread 2
SCHED_OTHER 3
thread 1
Pthread 1 exit
thread 2
Pthread 2 exit
thread 3
thread 3
thread 3
thread 3
thread 3
thread 3
thread 3
thread 3
thread 3
Pthread 3 exit

能肯定的一点事 线程3 抢不过线程 1 2 ，线程 1 2就相对复杂点。所以单靠优先级，来控制线程的先后执行，还是有一点牵强。

基于时间片轮转的实时进程是，不是真正的改变进程的优先级，而是改变进程的基本时间片的长度。所以基于时间片轮转的进程调度，并不能保证高优先级的进程先运行。

在linux下我们可以通过
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
    void *(*start_routine)(void*), void *arg);
来创建线程，但是如何设置线程的优先级呢？
在讨论这个问题的时候，我们先要确定当前线程使用的调度策略，posix提供了
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);函数来获取所
使用的调度策略，它们是：SCHED_FIFO, SCHED_RR 和 SCHED_OTHER。
我们可以使用
int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
来获取线程线程可是设置的最大和最小的优先级值，如果调用成功就返回最大和最小的优先级值，否则返回－1。
从我现在运行的linux系统中，我使用下列程序获取了对应三种调度策略中的最大和最小优先级：
policy = SCHED_OTHER
Show current configuration of priority
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
Set SCHED_RR policy
policy = SCHED_RR
Restore current policy
policy = SCHED_OTHER

我们可以看到
SCHED_OTHER是不支持优先级使用的，而SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，
数值越大优先级越高。 从上面的结果我们可以看出，如果程序控制线程的优先级，一般是用
pthread_attr_getschedpolicy来获取系统使用的调度策略，如果是SCHED_OTHER的话，表明当前策略
不支持线程优先级的使用，否则可以。当然所设定的优先级范围必须在最大和最小值之间。我们可以通过
sched_get_priority_max和sched_get_priority_min来获取。
可能网友会问，是否我们可以通过
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);来设定自己所需的
调度策略呢？我觉得是完全可以的（有些系统需要定义_POSIX_THREAD_PRIORITY_SCHEDULING），只要
系统实现了对应的调用策略。
说了半天，我们还没有说，在系统允许使用线程优先级别的时候，如何设置优先级别呢？
int pthread_attr_setschedparam(pthread_attr_t *attr, 
    const struct sched_param *param);
int pthread_attr_getschedparam(const pthread_attr_t *attr, 
    struct sched_param *param);
上面两个函数分别用于设置线程的优先级，struct sched_param的定义如下
struct sched_param
{
    int __sched_priority; //所要设定的线程优先级
};


#define SCHEDULER_PRIO 80
    /*************************/
    // change the scheduling policy and priority of this thread
    struct sched_param zSchedParam;
    int policy;
    int nResult;
    nResult = pthread_getschedparam(pthread_self(), &policy, &zSchedParam);
    assert(nResult == 0);
    zSchedParam.sched_priority = SCHEDULER_PRIO;
    nResult = pthread_setschedparam(pthread_self(), SCHED_FIFO, &zSchedParam);
    assert(nResult == 0);
    /**************************/
使用的测试程序：

#include <iostream>

#include <pthread.h>

#include <sched.h>

#include <assert.h>


using namespace std;


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:

                cout << "policy = SCHED_FIFO" << endl;

                break;


        case SCHED_RR:

                cout << "policy = SCHED_RR" << endl;

                break;


        case SCHED_OTHER:

                cout << "policy = SCHED_OTHER" << endl;

                break;


        default:

                cout << "policy = UNKNOWN" << endl;

                break;

        }


        return policy;

}


static void show_thread_priority( pthread_attr_t &attr, int policy )

{

        int priority = sched_get_priority_max( policy );

        assert( priority != -1 );

        cout << "max_priority = " << priority << endl;


        priority = sched_get_priority_min( policy );

        assert( priority != -1 );

        cout << "min_priority = " << priority << endl;

}


static int get_thread_priority( pthread_attr_t &attr )

{

        struct sched_param param;


        int rs = pthread_attr_getschedparam( &attr, &param );

        assert( rs == 0 );

        cout << "priority = " << param.__sched_priority << endl;


        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 );

        get_thread_policy( attr );

}


int main( void )

{

        pthread_attr_t attr;

        struct sched_param sched;

        int rs;


        rs = pthread_attr_init( &attr );

        assert( rs == 0 );


        int policy = get_thread_policy( attr );


        cout << "Show current configuration of priority" << endl;

        show_thread_priority( attr, policy );


        cout << "Show SCHED_FIFO of priority" << endl;

        show_thread_priority( attr, SCHED_FIFO );


        cout << "Show SCHED_RR of priority" << endl;

        show_thread_priority( attr, SCHED_RR );


        cout << "Show priority of current thread" << endl;

        int priority = get_thread_priority( attr );


        cout << "Set thread policy" << endl;

        cout << "Set SCHED_FIFO policy" << endl;

        set_thread_policy( attr, SCHED_FIFO );

        cout << "Set SCHED_RR policy" << endl;

        set_thread_policy( attr, SCHED_RR );

        cout << "Restore current policy" << endl;

        set_thread_policy( attr, policy );



        rs = pthread_attr_destroy( &attr );

        assert( rs == 0 );


        return 0;

}

在linux下我们可以通过
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
    void *(*start_routine)(void*), void *arg);
来创建线程，但是如何设置线程的优先级呢？
在讨论这个问题的时候，我们先要确定当前线程使用的调度策略，posix提供了
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);函数来获取所
使用的调度策略，它们是：SCHED_FIFO, SCHED_RR 和 SCHED_OTHER。
我们可以使用
int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
来获取线程线程可是设置的最大和最小的优先级值，如果调用成功就返回最大和最小的优先级值，否则返回－1。
从我现在运行的linux系统中，我使用下列程序获取了对应三种调度策略中的最大和最小优先级：
policy = SCHED_OTHER
Show current configuration of priority
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
Set SCHED_RR policy
policy = SCHED_RR
Restore current policy
policy = SCHED_OTHER

我们可以看到
SCHED_OTHER是不支持优先级使用的，而SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，
数值越大优先级越高。 从上面的结果我们可以看出，如果程序控制线程的优先级，一般是用
pthread_attr_getschedpolicy来获取系统使用的调度策略，如果是SCHED_OTHER的话，表明当前策略
不支持线程优先级的使用，否则可以。当然所设定的优先级范围必须在最大和最小值之间。我们可以通过
sched_get_priority_max和sched_get_priority_min来获取。
可能网友会问，是否我们可以通过
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);来设定自己所需的
调度策略呢？我觉得是完全可以的（有些系统需要定义_POSIX_THREAD_PRIORITY_SCHEDULING），只要
系统实现了对应的调用策略。
说了半天，我们还没有说，在系统允许使用线程优先级别的时候，如何设置优先级别呢？
int pthread_attr_setschedparam(pthread_attr_t *attr, 
    const struct sched_param *param);
int pthread_attr_getschedparam(const pthread_attr_t *attr, 
    struct sched_param *param);
上面两个函数分别用于设置线程的优先级，struct sched_param的定义如下
struct sched_param
{
    int __sched_priority; //所要设定的线程优先级
};


使用的测试程序：


#include <iostream>

#include <pthread.h>

#include <sched.h>

#include <assert.h>


using namespace std;


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:

                cout << "policy = SCHED_FIFO" << endl;

                break;


        case SCHED_RR:

                cout << "policy = SCHED_RR" << endl;

                break;


        case SCHED_OTHER:

                cout << "policy = SCHED_OTHER" << endl;

                break;


        default:

                cout << "policy = UNKNOWN" << endl;

                break;

        }


        return policy;

}


static void show_thread_priority( pthread_attr_t &attr, int policy )

{

        int priority = sched_get_priority_max( policy );

        assert( priority != -1 );

        cout << "max_priority = " << priority << endl;


        priority = sched_get_priority_min( policy );

        assert( priority != -1 );

        cout << "min_priority = " << priority << endl;

}


static int get_thread_priority( pthread_attr_t &attr )

{

        struct sched_param param;


        int rs = pthread_attr_getschedparam( &attr, &param );

        assert( rs == 0 );

        cout << "priority = " << param.__sched_priority << endl;


        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 );

        get_thread_policy( attr );

}


int main( void )

{

        pthread_attr_t attr;

        struct sched_param sched;

        int rs;


        rs = pthread_attr_init( &attr );

        assert( rs == 0 );


        int policy = get_thread_policy( attr );


        cout << "Show current configuration of priority" << endl;

        show_thread_priority( attr, policy );


        cout << "Show SCHED_FIFO of priority" << endl;

        show_thread_priority( attr, SCHED_FIFO );


        cout << "Show SCHED_RR of priority" << endl;

        show_thread_priority( attr, SCHED_RR );


        cout << "Show priority of current thread" << endl;

        int priority = get_thread_priority( attr );


        cout << "Set thread policy" << endl;

        cout << "Set SCHED_FIFO policy" << endl;

        set_thread_policy( attr, SCHED_FIFO );

        cout << "Set SCHED_RR policy" << endl;

        set_thread_policy( attr, SCHED_RR );

        cout << "Restore current policy" << endl;

        set_thread_policy( attr, policy );



        rs = pthread_attr_destroy( &attr );

        assert( rs == 0 );


        return 0;

}

linux中设置线程优先级
How to set swap priority in Linux? Can I use 2 swap partition at the same time?
 如何在Linux中设置交换优先级？ 我可以同时使用2个交换分区吗？ 
You can set the priority of swap in Linux by swapon.
 您可以通过swapon在Linux中设置交换的优先级。 
For example, to set /dev/sdc1‘s priority to 0:
 例如，将/dev/sdc1的优先级设置为0： 
# swapoff /dev/sdc1; swapon -p 0 /dev/sdc1
You can also put one entry into the /etc/fstab to make it take effect each time Linux reboots:
 您还可以在/etc/ fstab放入一个条目，以使其在每次Linux重新启动时生效： 
/dev/sdc1 swap swap pri=0 0 0
You can set 2 swap partions to have the same priority, pages are allocated on a round-robin basis between them.
 您可以将2个交换分区设置为具有相同的优先级，页面在它们之间以循环方式分配。 
Priority
 优先 
Each swap area has a priority, either high or low. The default
 priority is low. Within the low-priority areas, newer areas are even
 lower priority than older areas. All priorities set with swapflags are
 high-priority, higher than default. They may have any non-negative
 value chosen by the caller. Higher numbers mean higher priority.
 每个交换区域都有一个高优先级或低优先级。 默认值 
 优先级低。 在低优先级区域中，较新的区域甚至 
 优先级低于较老地区。 所有带有swapflags设置的优先级为 
 高优先级，高于默认值。 他们可能有任何非负数 
 呼叫者选择的值。 数字越高意味着优先级越高。 
Swap pages are allocated from areas in priority order, highest
 priority first. For areas with different priorities, a higher-priority
 area is exhausted before using a lower-priority area. If two or more
 areas have the same priority, and it is the highest priority
 available, pages are allocated on a round-robin basis between them.
 交换页面是按优先级从高到低的顺序分配的 
 优先优先。 对于优先级不同的区域，优先级较高 
 使用较低优先级的区域之前，该区域已耗尽。 如果两个或更多 
 区域具有相同的优先级，这是最高优先级 
 如果可用，页面将在它们之间以循环方式分配。 
As of Linux 1.3.6, the kernel usually follows these rules, but there
 are exceptions.
 从Linux 1.3.6开始，内核通常遵循以下规则，但是 
 是例外。 
From swapon manual.
 从swapon手册。 
翻译自: https://www.systutorials.com/how-to-set-swap-priority-in-linux/
linux中设置线程优先级