1. 程式人生 > >如何在linux中設定執行緒的優先順序

如何在linux中設定執行緒的優先順序

在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。

SCHED_OTHER 分時排程策略,
SCHED_FIFO  實時排程策略,先到先服務
SCHED_RR    實時排程策略,時間片輪轉 

我們可以使用

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; //所要設定的執行緒優先順序
};

使用的測試程式:

    // pthread_test.cpp    
    #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設定執行優先順序

在linux下我們可以通過 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg

如何在linux/unix設定執行優先順序

 在linux下我們可以通過int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);來建立執行緒,但是如何設定執行緒的優先順序呢?在討論這個問題

在spring引入執行池,設定執行優先順序

在spring.xml 檔案中配置: <!-- 執行緒--> <bean id="taskExecutor" class="org.springframework.sc

Linuxepoll+執行池實現高併發

伺服器併發模型通常可分為單執行緒和多執行緒模型,這裡的執行緒通常是指“I/O執行緒”,即負責I/O操作,協調分配任務的“管理執行緒”,而實際的請求和任務通常交由所謂“工作者執行緒”處理。通常多執行緒模型下,每個執行緒既是I/O執行緒又是工作者執行緒。所以這裡討論的是,單I/O執行緒+多工作者執行緒的模型,這也

java設定執行優先順序的誤區

對執行緒有一些瞭解的讀者知道,線上程中,我們可以通過執行緒的setPriority()方法來設定執行緒的優先順序,方法的引數是一個整型值,可以填寫從1~10的值。當我們建立執行緒的時候,java預設給執行緒設定的優先順序是5,1為最低優先順序,10為最高優先順序。下面的例子建立了a,b兩個執

Linux執行區域性儲存

在Linux系統中使用C/C++進行多執行緒程式設計時,我們遇到最多的就是對同一變數的多執行緒讀寫問題,大多情況下遇到這類問題都是通過鎖機制來處理,但這對程式的效能帶來了很大的影響,當然對於那些系統原生支援原子操作的資料型別來說,我們可以使用原子操作來處理,這能

每天進步一點點——Linux執行區域性儲存(二)

凡是帶有__thread的變數,每個執行緒都擁有該變數的一份拷貝,且互不干擾。執行緒區域性儲存中的變數將一直存在,直至執行緒終止,當執行緒終止時會自動釋放這一儲存。__thread並不是所有資料型別都可以使用的,因為其只支援POD(Plain old data structure)[1]型別,不支援clas

LInux利用執行實現多個客戶端和伺服器端進行通訊

上一篇博文講了如何利用子程序實現多個客戶端和伺服器端進行通訊, 那麼,這一篇部落格就來實現一下如何利用執行緒實現多個客戶端和伺服器端進行通訊 程式碼實現: ser1.c #include <

Linuxpthread_detach()執行注意

一、建立分離執行緒有兩種方式建立分離執行緒:(1)線上程建立時將其屬性設為分離狀態(detached);(2)線上程建立後將其屬性設為分離的(detached)。二、分離執行緒的作用由系統來回收執行緒所佔用資源。三、例項#include <stdlib.h>#in

執行執行設定超時退出監控

前言 在寫多執行緒程式時,大多數情況下會先excutor建立執行緒池,然後再建立執行緒,但是對一些讀資料庫或者其他IO操作,容易堵住執行緒,此時就需要給執行緒設定超時時間,幹掉超時的執行緒再重新拉起一個執行緒來,但是java執行緒建立並沒有預留超時引數,研究了一下網上也沒找到

Linux/Windows下C++設定執行名字方便多執行除錯

C++多執行緒程式設計,除錯是一個大問題,原因之一就是,執行緒名字繼承了父程序的名字,因此導致同一段程式碼的不同執行緒名字一樣;而且還會導致執行緒的名字怪怪的,不好看。 因此,如果在程式碼中可以設定執行緒的名字就好了,這樣在除錯中就可以看到期望的執行緒名字,這樣便於除錯。 由於編

Linux程序或執行繫結到CPU+修改優先順序

  轉載自 https://www.cnblogs.com/swey/p/4469722.html 為了讓程式擁有更好的效能,有時候需要將程序或執行緒繫結到特定的CPU,這樣可以減少排程的開銷和保護關鍵程序或執行緒。 程序繫結到CPU Linux提供一個介面,可以

Linux 執行】同一個程序執行共享哪些資源

程序是具有一定獨立功能的程式關於某個資料集合上的一次執行活動,程序是系統進行資源分配和排程的一個獨立單位.  執行緒是程序的一個實體,是CPU排程和分派的基本單位,它是比程序更小的能獨立執行的基本單位.執行緒自己基本上不擁有系統資源,只擁有一點在執行中必不可少的資源(如程式計數器,一組暫存器和棧)

linux下一個程序執行的資源共享

在說執行緒資源共享之前,我們先來說來說一下執行緒的概念,執行緒是程序內部的一條執行序列(即執行流),一個程序至少有一個執行緒,即main函式代表的執行流。當然我們也可以通過執行緒庫來建立新的執行緒,這種執行緒我們稱之為函式執行緒,同一個程序中的所有普執行緒是併發執行的。而這些

Linux核心執行及多執行

一、執行緒的概念、理解及特點     1.執行緒的概念:         至今為止,Linux下還是沒有“真正的執行緒”。談到執行緒就不得不提到程序這概念,程序是系統中程式執行和資源分配的基本單位。每個程序都擁有自己的資料段,程式碼段和堆疊段,這就造成了程序在進行切換

Linux核心執行死鎖

一、死鎖的概念     1.什麼是死鎖:       死鎖 (deadlocks): 是指兩個或兩個以上的程序(執行緒)在執行過程中,因爭奪資源而造成的一種互相等待的現象,若無外力作用,它們都將無法推進下去。此時稱系統處於死鎖狀態或系統產生了死鎖,這些永遠在互相等待的

linux 下檢視某一程序的cpu使用率和這個執行各個執行的cpu使用率

在Ubuntu/CentOS等linux系統中, 在除錯程式過程中,有時需要檢視程式的CPU的使用率和程式的各個程序的使用率. 那麼首先需要獲取這個程序的PID: ps -ef|grep [process name] 然後檢視該程序的CPU: top -p [PID]

linux java 查詢程序執行

這裡對linux下、sun(oracle) JDK的執行緒資源佔用問題的查詢步驟做一個小結; linux環境下,當發現java程序佔用CPU資源很高,且又要想更進一步查出哪一個java執行緒佔用了CPU資源時,按照以下步驟進行查詢: (一):通過【 top -p12377-

Android 執行優先順序設定方法

http://www.cnblogs.com/liulipeng/archive/2013/02/25/2932572.html 對於Android平臺上的執行緒優先順序設定來說可以處理很多併發執

java設定執行執行的名字

專案中使用ThreadPoolExecutor進行多執行緒開發。使用起來很方便,但是當用jstack檢視堆疊資訊或者Jprofiler除錯效能的時候,看到的執行緒都是pool-1-thread-1\2\3\4之類的。如果一個系統中用到了多個執行緒池,就無法區分哪個執行緒造