typedef struct
{

    int etachstate;         //線程的分離狀態(tài)

    int schedpolicy;        //線程調(diào)度策略

    struct sched_param schedparam;  //線程的調(diào)度參數(shù)

    int inheritsched;       //線程的繼承性

    int scope;          //線程的作用域

    size_t guardsize;       //線程棧末尾的警戒緩沖區(qū)大小

    int stackaddr_set;      //線程的棧設(shè)置

    void* stackaddr;        //線程棧的位置

    size_t stacksize;       //線程棧的大小

}pthread_attr_t;

對(duì)線程屬性的設(shè)置

屬性對(duì)象創(chuàng)建銷毀，繼承性捷沸，調(diào)度策略摊沉，優(yōu)先權(quán)，分離狀態(tài)痒给，棧

初始化/銷毀線程的屬性對(duì)象

#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destory(pthread_attr_t *attr);

使用一個(gè)線程對(duì)象之前说墨，必須對(duì)其進(jìn)行初始化

線程的繼承性

線程的繼承性指是否繼承創(chuàng)建線程的調(diào)度策略和參數(shù)

#include <pthread.h>
//獲取線程的繼承性
int pthread_attr_getinheritsched(const pthread_attr_t *attr,int *inheritsched);
//設(shè)置線程的繼承性
int pthread_attr_setinheritsched(pthread_attr_t*attr,int inheritschesd);

繼承性inheritsched可取的值：
PTHREAD_INHERIT_SCHED:新進(jìn)程繼承線程的調(diào)度策略和參數(shù)
PTHREAD_EXPLICIT_SCHED:新進(jìn)程通過(guò)schedpolicy和schedparam顯示設(shè)置調(diào)度策略和調(diào)度參數(shù)

線程調(diào)度策略

#include <pthread.h>
//獲取線程的調(diào)度策略
int pthread_attr_getschedpolicy(const pthread_attr_t *attr,int *policy)
//設(shè)置線程的調(diào)度策略
int pthread_attr_setschedpolicy(pthread_attr_t *attr,int *policy)

調(diào)度策略policy可取的值：
SCHED_FIFO:先來(lái)先服務(wù)
SCHED_RR：時(shí)間片輪轉(zhuǎn)
SCHED_OTHER：非實(shí)時(shí)（默認(rèn)）

線程調(diào)度參數(shù)

設(shè)置線程的優(yōu)先級(jí)

#include <pthread.h>
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);

結(jié)構(gòu)體sched_param定義如下

struct sched_param {
               int sched_priority;     /* Scheduling priority */
           };

優(yōu)先級(jí)設(shè)置中，數(shù)值越大優(yōu)先權(quán)越高苍柏∧岣可用下面兩個(gè)函數(shù)獲取最大和最小優(yōu)選權(quán)值

• sched_get_priority_max()
• sched_get_priority_min()

線程分離屬性

#include <pthread.h>
       int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
       int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

detachstate的值：
PTHREAD_CREATE_DETACHED
PTHREAD_CREATE_JOINABLE

堆棧信息

• 堆棧大小

#include <pthread.h>
       int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
       int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);

stacksize：
PTHREAD_STACK_MIN：默認(rèn)，最小堆棧大小
自定義：必須大于PTHREAD_STACK_MIN,一般為 STACK_ALIGN的倍數(shù)

• 堆棧地址

#include <pthread.h>
       int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
       int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr);

• 堆棧信息（堆棧大小和地址）

#include <pthread.h>
int pthread_attr_setstack(pthread_attr_t *attr,
                          void *stackaddr, size_t stacksize);
int pthread_attr_getstack(pthread_attr_t *attr,
                          void **stackaddr, size_t *stacksize);

獲取已創(chuàng)建屬性

#define _GNU_SOURCE         
#include <pthread.h>
int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);

示例代碼

• 獲仁杂酢（默認(rèn)）屬性信息

//#define _GNU_SOURCE //加上后說(shuō)重定義了我也不知道為啥
#include <pthread.h>
#include <unistd.h>
#include <iostream>
using namespace std;
void display(pthread_attr_t *attr)
{
    int inheritsched;
    int policy;
    struct sched_param param;
    int detachstate;
    size_t stacksize;
    void *stackaddr;
    pthread_attr_getinheritsched(attr,&inheritsched);
    pthread_attr_getschedpolicy(attr,&policy);
    pthread_attr_getschedparam(attr,&param);
    pthread_attr_getdetachstate(attr,&detachstate);
    pthread_attr_getstack(attr,&stackaddr,&stacksize);
    if(inheritsched == PTHREAD_EXPLICIT_SCHED)
    {       
        cout << "inheritsched  is PTHREAD_EXPLICIT_SCHED"<<endl;
    }else if(inheritsched == PTHREAD_INHERIT_SCHED) 
    {       
        cout << "inheritsched  is PTHREAD_INHERIT_SCHED"<<endl;
    }

    if(policy == SCHED_OTHER)
    {       
        cout << "policy is SCHED_OTHER"<<endl;
    }   

    cout << "priority is "<<param.sched_priority<<endl;
    if(detachstate==PTHREAD_CREATE_JOINABLE)
    {
    cout << "detachstate is PTHREAD_CREATE_JOINABLE"<<endl;
    }
    else if(detachstate==PTHREAD_CREATE_DETACHED)
    {
    cout << "detachstate is PTHREAD_CREATE_DETACHED"<<endl;
        
    }   
    cout << "stackaddr is "<<stackaddr<<endl;
    cout << "stacksize is "<< stacksize<<endl;

}
void * fun(void *arg)
{
    pthread_attr_t attr;
    pthread_getattr_np(pthread_self(),&attr);
    display(&attr);
}
int main()
{


    pthread_t thread;

    pthread_attr_t *attr;
    pthread_attr_init(attr);
/********set***********/


/********set***********/
    pthread_create(&thread,attr,fun,NULL);  
    pthread_join(thread,NULL);
    pthread_attr_destroy(attr);
    return 0;
}

運(yùn)行結(jié)果

結(jié)果顯示
給棧分配了

512個(gè)PTHREAD_STACK_MIN（整數(shù)倍）