初始化/銷燬執行緒屬性

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

執行緒分離屬性

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

引數說明：

The following values may be specified in detachstate:

   PTHREAD_CREATE_DETACHED

Threads that are created using attr will be created in a detached state.

   PTHREAD_CREATE_JOINABLE

Threads that are created using attr will be created in a joinable state.

The  default  setting  of  the  detach  state  attribute  in  a  newly initialized 

threadattributes object is PTHREAD_CREATE_JOINABLE

The pthread_attr_getdetachstate() returns  the  detach  state  attribute  of  the  

threadattributes object attr in the buffer pointed to by detachstate.

執行緒棧大小

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);
 

DESCRIPTION

  The pthread_attr_setstacksize() function sets the stack  size  attribute  

of  the  threadattributes object referred to by attr to the value specified 

in stacksize.(一般情況下該值我們設定為0，使用系統預設設定的執行緒棧大小，否則可能會引起程式的可移植性的問題)       The  stack  size  attribute determines the minimum size (in bytes) that will 

be allocatedfor threads created using the thread attributes object attr.

  The pthread_attr_getstacksize() function returns the stack size attribute of  

the  threadattributes object referred to by attr in the buffer pointed to by stacksize.

執行緒棧溢位保護區大小

int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
int pthread_attr_getguardsize(pthread_attr_t *attr, size_t *guardsize);

執行緒競爭範圍(程序範圍內的競爭　or　系統範圍內的競爭)

int pthread_attr_getscope(const pthread_attr_t *attr,int *contentionscope);
int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);

contentionscope說明：

   PTHREAD_SCOPE_SYSTEM

The  thread  competes for resources with all other threads in all processes on 

the system that are in the same scheduling allocation domain (a group of one  or  more processors).   

PTHREAD_SCOPE_SYSTEM  threads are scheduled relative to one anotheraccording to their 

scheduling policy and priority.

   PTHREAD_SCOPE_PROCESS

The thread competes for resources with all other threads in the same process  thatwere    

also created with the PTHREAD_SCOPE_PROCESS contention scope.

  PTHREAD_SCOPE_PROCESS threads are scheduled  relative  to  other  threads  in  the process 

according to their scheduling policy and priority.  POSIX.1-2001 leaves it unspecified how these threads contend with other threads in other process  

on  the system  or  with  other  threads  in  the  same process that were created with the 

PTHREAD_SCOPE_SYSTEM contention scope.

執行緒排程策略

int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

DESCRIPTION

 The pthread_attr_setschedpolicy() function sets the scheduling policy  attribute  of  the thread  

attributes  object  referred  to  by attr to the value specified in policy.  This attribute determines  

the  scheduling  policy  of  a  thread  created  using  the  thread attributes object attr.

 The  supported  values  for  policy  are  SCHED_FIFO, SCHED_RR, and SCHED_OTHER, as below:

  SCHED_FIFO    a first-in, first-out policy(先進先出排程策略); 

  SCHED_RR      a round-robin policy(時間片輪轉排程演算法);

  SCHED_OTHER   the standard round-robin time-sharing policy(執行緒一旦開始執行，直到被搶佔或者直到執行緒阻塞或停止為止);

注意:

 In order for the policy setting made by pthread_attr_setschedpolicy() 

to have effect when calling pthread_create(3), the caller must use pthread_attr_setinheritsched(3)(見下) 

to set the inherit-scheduler attribute of the attributes object attr to PTHREAD_EXPLICIT_SCHED(新建立的程序繼承自己的排程屬性).

執行緒繼承的排程策略

int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched);
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched);

The following values may be specified in inheritsched:

  PTHREAD_INHERIT_SCHED(繼承排程屬性)

Threads that are created using attr inherit scheduling attributes from the  

creating thread; the scheduling attributes in attr are ignored.

  PTHREAD_EXPLICIT_SCHED(指定自己的排程屬性)

Threads that are created using attr take their scheduling attributes from 

the values specified by the attributes object.

The default setting of the inherit-scheduler attribute  in  a  newly  initialized  thread attributes object is PTHREAD_INHERIT_SCHED.

執行緒排程引數(實際上我們一般只關心一個引數：執行緒的優先順序,預設為0)

int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);

//sched_param結構體
struct sched_param {
    int sched_priority;     /* Scheduling priority */
};

執行緒的併發級別

int pthread_setconcurrency(int new_level);
int pthread_getconcurrency(void);

說明：併發級別僅在N:M執行緒模型中有效，設定併發級別，給核心一個提示：表示提供給定級別數量的核心執行緒來對映使用者執行緒是高效的(僅僅是一個提示)，預設為0, 核心按照預設的方式進行併發；

/** 檢視執行緒預設屬性 **/
void printThreadAttr()
{
    pthread_attr_t attr;
    pthread_attr_init(&attr);

    int detachstate;
    pthread_attr_getdetachstate(&attr, &detachstate);
    cout << "detach-state: "
         << (detachstate == PTHREAD_CREATE_JOINABLE ?
             "PTHREAD_CREATE_JOINABLE" : "PTHREAD_CREATE_DETACHED")
         << endl;

    size_t size;
    pthread_attr_getstacksize(&attr, &size);
    cout << "stack-size: " << size << endl;

    pthread_attr_getguardsize(&attr, &size);
    cout << "guard-size: " << size << endl;

    int scope;
    pthread_attr_getscope(&attr, &scope);
    cout << "scope: "
         << (scope == PTHREAD_SCOPE_SYSTEM ?
             "PTHREAD_SCOPE_SYSTEM" : "PTHREAD_SCOPE_PROCESS")
         << endl;

    int policy;
    pthread_attr_getschedpolicy(&attr, &policy);
    cout << "policy: ";
    switch (policy)
    {
    case SCHED_FIFO:
        cout << "SCHED_FIFO";
        break;
    case SCHED_RR:
        cout << "SCHED_RR";
        break;
    case SCHED_OTHER:
        cout << "SCHED_OTHER";
        break;
    default:
        break;
    }
    cout << endl;

    int inheritsched;
    pthread_attr_getinheritsched(&attr, &inheritsched);
    cout << "inheritsched: "
         << (inheritsched == PTHREAD_INHERIT_SCHED ?
             "PTHREAD_INHERIT_SCHED" : "PTHREAD_INHERIT_SCHED")
         << endl;

    struct sched_param param;
    pthread_attr_getschedparam(&attr, ¶m);
    cout << "scheduling priority: " << param.sched_priority << endl;
    cout << "concurrency: " << pthread_getconcurrency() << endl;
    pthread_attr_destroy(&attr);
}

說明:

繫結屬性:

  Linux中採用“一對一”的執行緒機制，也就是一個使用者執行緒對應一個核心執行緒。繫結屬性就是指一個使用者執行緒固定地分配給一個核心執行緒，因為CPU時間片的排程是面向核心執行緒（也就是輕量級程序）的，因此具有繫結屬性的執行緒可以保證在需要的時候總有一個核心執行緒與之對應。而與之對應的非繫結屬性就是指使用者執行緒和核心執行緒的關係不是始終固定的，而是由系統來控制分配的。

分離屬性:

  分離屬性是用來決定一個執行緒以什麼樣的方式來終止自己。在非分離情況下，當一個執行緒結束時，它所佔用的系統資源並沒有被釋放，也就是沒有真正的終止。只有當pthread_join()函式返回時，建立的執行緒才能釋放自己佔用的系統資源。而在分離屬性情況下，一個執行緒結束時立即釋放它所佔有的系統資源。這裡要注意的一點是，如果設定一個執行緒的分離屬性，而這個執行緒執行又非常快，那麼它很可能在pthread_create()函式返回之前就終止了，它終止以後就可能將執行緒號和系統資源移交給其他的執行緒使用。