linux線程的優先順序

A. linux 怎麼查看線程優先順序

你好。 在分時系統里應該沒什必要吧 setpriority/getpriority，這兩個函數描述的是改變進程優先順序。 但是在linux中線程就是一個輕量級的進程， 所以這兩個函數是可以作用於單獨的線程的 如果我的回答沒能幫助您，請繼續追問。

B. linux查看線程優先順序命令

用top或者ps -l查看進程會發現有PR(PRI) NI兩個欄位：

NI 是優先值，是用戶層面的概念， PR是進程的實際優先順序， 是給內核（kernel）看（用）的。
一般情況下，PR=NI+20, 如果一個進程的優先順序PR是20， 那麼它的NI(nice)值就是20-20=0。
進程調度優先順序是從-20到19，一共40個級別，數字越大，表示進程的優先順序越低。默認時候，進程的優先順序是0。查看進程優先順序有兩個辦法：ps和top。top命令顯示的NI列的值。或者可以使用ps -efl來查看，也是在ni列表示了進程的優先順序。《Linux就該這么學》 一起學習，進程的優先順序可以在程序運行的時候設置，也可以在程序運行過程中動態的修改。

C. 淺析Linux下進程的調度策略與優先順序

在 Linux 中，線程是由進程來實現的，可以認為線程就是一個輕量級的進程，因此，線程調度是按照進程調度的方式來進行的。這樣設計，線程調度流程可以直接復用進程調度流程，沒必要再設計一個進程內的線程調度器了。

在 Linux 中，進程調度器是基於進程的調度策略與調度優先順序來決定調度哪個進程運行。

調度策略主要包括：

調度優先順序的范圍是 0~99，數值越大，表示優先順序越高。

其中，SCHED_OTHER、SCHED_IDLE、SCHED_BACH 為非實時調度策略，其調度優先順序為 0。而 SCHED_FIFO、SCHED_RR 是實時調度策略，其調度優先順序范圍為 1~99。

實時調度策略的進程總是比非實時調度策略的進程優先順序高。

在 Linux 內部實現中，調度器會為每個可能的調度優先順序維護一個可運行的進程列表，以最高優先順序列表頭部的進程作為下一次調度的進程，所有的調度都是搶占式的，如果一個具有更高調度優先順序的進程轉換為可運行狀態，那麼當前運行的進程將被強制進入其等待的隊列中。

SCHED_OTHER

該調度策略是默認的 Linux 分時調度策略，該調度策略為非實時的，其調度優先順序總是為 0。

對於該調度策略類型的進程，調度器是基於動態優先順序來調度的。動態優先順序跟屬性 nice 有關，nice 的值會隨著進程的運行時間而動態改變，以確保所有具有 SCHED_OTHER 策略的進程公平地得到調度。

在 Linux 中，nice 的值范圍為-20 ~ +19，默認值為 0。nice 值越大，則優先順序越低，因此相對較低 nice 值的進程可以獲得更多的處理器時間。

通過命令 ps -el 查看系統中的進程列表，其中 NI 列就是進程對應的 nice 值。

使用 top 命令，看到的 NI 列也是進程的 nice 值。

調整 nice 值，可以通過 shell 命令 nice ，該命令可以按照指定的 nice 值運行 cmd ，命令的幫助信息為：

重新調整已運行進程的 nice 值，可通過 renice 命令實現，命令的幫助信息為：

另外，可以執行 top 命令，輸入 r ，根據提示輸入進程的 pid ，再輸入 nice 數值，也可以調整進程的 nice 值。

SCHED_FIFO

該調度策略為先入先出調度策略，簡單概括，就是一旦進程佔用了 CPU，則一直運行，直到有更高優先順序的任務搶占，或者進程自己放棄佔用 CPU。

SCHED_RR

該調度策略為時間片輪轉調度策略，該調度策略是基於 SCHED_FIFO 策略的演進，其在每個進程上增加一個時間片限制，當時間片使用完成後，調度器將該進程置於隊列的尾端，放在尾端保證了所有具有相同調度優先順序的進程的調度公平。

使用 top 命令，如果 PR 列的值為 RT ，則說明該進程採用的是實時調度策略，其調度策略為 SCHED_FIFO 或者 SCHED_RR，而對於非實時調度策略的進程，該列的值為 NI + 20 。

可以通過命令 ps -eo state,uid,pid,ppid,rtprio,time,comm 來查看進程對應的實時優先順序，實時優先順序位於 RTPRIO 列下，如果進程對應的列顯示為 - ，說明該進程不是實時進程。

chrt 命令可以用來很簡單地更改進程的調度策略與調度優先順序。在 Linux 下查看 chrt 命令的幫助信息：

比如，獲取某個進程的調度策略，使用如下命令：

在比如，設置某個進程的調度策略為 SCHED_FIFO，調度優先順序為 70，使用如下命令：

D. 在Linux下怎麼修改當前線程的優先順序

注意：盡量不要修改系統默認優先順序

Thread類與線程優先順序相關的屬性和方法：

MAX_PRIORITY : 線程可以具有最高優先順序
MIN_PRIORITY : 線程可以具有的最低優先順序
NORM_PRIORITY : 分配給線程的默認優先順序
getPriority() : 獲得線程的優先順序
setPriority() : 修改線程的優先順序

java">importjava.util.Scanner;

{

	publicstaticThread[]getThreads(){
		ThreadGroupgroup=Thread.currentThread().getThreadGroup();
		Thread[]threads=newThread[group.activeCount()];
		group.enumerate(threads);
		System.out.println("線程ID	"+"線程名稱	"+"線程優先順序");
		for(Threadthread:threads){
			System.out.println(thread.getId()+"	"+thread.getName()+"	"+thread.getPriority());;
			
		}
		returnthreads;
		
	}
	publicstaticStringinput(){
		Scannersc=newScanner(System.in);
		Stringstr=sc.nextLine();
		returnstr;
		}

	(Thread[]threads){
		System.out.println("請輸入您要修改的線程的ID");
		inti=Integer.parseInt(input());
		intcount=-1;
		for(Threadthread:threads){
			if(thread.getId()==i){
				System.out.println("請輸入您要修改成的優先順序別：");
				intpriroty=Integer.parseInt(input());
				thread.setPriority(priroty);
				break;
			}else{
				count++;
			}
		}
		if(count==threads.length-1){
			System.out.println("找不到您要的線程");
		}
		getThreads();

	}
	publicstaticvoidmain(String[]args){
		modifyPriority(getThreads());
	}
}

E. Linux編程線程優先順序，主程序創建了兩個線程A、B

可以通過設置線程優先順序。
在創建線程前使用pthread_attr_init對創建線程的參數pthread_attr_t進行初始化，其中包括優先順序參數，然後在創建線程時傳入參數即可。具體使用方法可以參考man手冊

F. 如何在linux/unix中設置線程的優先順序

我們使用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; //所要設定的線程優先順序
};
例：創建優先順序為10的線程
pthread_attr_t attr;
struct sched_param param;
pthread_attr_init(&attr);
pthread_attr_setschedpolicy(&attr, SCHED_RR);
param.sched_priority = 10;
pthread_attr_setschedparam(&attr, ¶m);
pthread_create(xxx , &attr , xxx , xxx);
pthread_attr_destroy(&attr);

附：使用的測試程序：
#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, ¶m );
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;
}

編譯命令：
#g++ pthread_priority3.c -o pthread_priority3 -lpthread

G. linux進程、線程及調度演算法（三）

調度策略值得是大家都在ready時，並且CPU已經被調度時，決定誰來運行，誰來被調度。

兩者之間有一定矛盾。
響應的優化，意味著高優先順序會搶占優先順序，會花時間在上下文切換，會影響吞吐。
上下文切換的時間是很短的，幾微妙就能搞定。上下文切換本身對吞吐並多大影響， 重要的是，切換後引起的cpu 的 cache miss.
每次切換APP, 數據都要重新load一次。
Linux 會盡可能的在響應與吞吐之間尋找平衡。比如在編譯linux的時候，會讓你選擇 kernal features -> Preemption model.
搶占模型會影響linux的調度演算法。

所以 ARM 的架構都是big+LITTLE， 一個很猛CPU+ 多個 性能較差的 CPU, 那麼可以把I/O型任務的調度 放在 LITTLE CPU上。需要計算的放在big上。

早期2.6 內核將優先順序劃分了 0-139 bit的優先順序。數值越低，優先順序越高。0-99優先順序 都是 RT（即時響應）的 ，100-139都是非RT的，即normal。
調度的時候 看哪個bitmap 中的 優先順序上有任務ready。可能多個任務哦。

在普通優先順序線程調度中，高優先順序並不代表對低優先順序的絕對優勢。會在不同優先順序進行輪轉。
100 就是比101高，101也會比102高，但100 不會堵著101。
眾屌絲進程在輪轉時，優先順序高的：

初始設置nice值為0，linux 會探測 你是喜歡睡眠，還是幹活。越喜歡睡，linux 越獎勵你，優先順序上升（nice值減少）。越喜歡幹活，優先順序下降（nice值增加）。所以一個進程在linux中，干著干著 優先順序越低，睡著睡著 優先順序越高。

後期linux補丁中

紅黑樹，數據結構， 左邊節點小於右邊節點
同時兼顧了 CPU/IO 和 nice。
數值代表著 進程運行到目前為止的virtual runtime 時間。

（pyhsical runtime） / weight * 1024(系數)。
優先調度 節點值（vruntime）最小的線程。權重weight 其實有nice 來控制。

一個線程一旦被調度到，則物理運行時間增加，vruntime增加，往左邊走。
weight的增加，也導致vruntime減小，往右邊走。
總之 CFS讓線程 從左滾到右，從右滾到左。即照顧了I/O(喜歡睡，分子小) 也 照顧了 nice值低（分母高）.所以 由喜歡睡，nice值又低的線程，最容易被調度到。
自動調整，無需向nice一樣做出獎勵懲罰動作，個人理解權重其實相當於nice

但是 此時 來一個 0-99的線程，進行RT調度，都可以瞬間秒殺你！因為人家不是普通的，是RT的!

一個多線程的進程中，每個線程的調度的策略 如 fifo rr normal, 都可以不同。每一個的優先順序都可以不一樣。
實驗舉例, 創建2個線程，同時開2個：

運行2次，創建兩個進程
sudo renice -n -5(nice -5級別) -g(global)， 會明顯看到 一個進程的CPU佔用率是另一個的 3倍。

為什麼cpu都已經達到200%，為什麼系統不覺得卡呢？因為，我們的線程在未設置優先順序時，是normal調度模式，且是 CPU消耗型 調度級別其實不高。

利用chrt工具，可以將進程 調整為 50 從normal的調度策略 升為RT （fifo）級別的調度策略，會出現：

chrt , nice renice 的調度策略 都是以線程為單位的，以上 設置的將進程下的所有線程進行設置nice值
線程是調度單位，進程不是，進程是資源封裝單位！

兩個同樣死循環的normal優先順序線程，其中一個nice值降低，該線程的CPU 利用率就會比另一個CPU的利用率高。