1.【线程属性】
线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。
调用pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现支持的线程所有属性的默认值。
如果要去除对pthread_attr_t结构的初始化，可以调用pthread_attr_destroy函数。如果pthread_attr_init实现时为属性对象分配了动态内存空间，pthread_attr_destroy还会用无效的值初始化属性对象，因此如果经pthread_attr_destroy去除初始化之后的pthread_attr_t结构被pthread_create函数调用，将会导致其返回错误。

1. typedef struct

2. {

3. int detachstate; // 线程的分离状态

4. int schedpolicy; // 线程调度策略

5. structsched_param schedparam; // 线程的调度参数

6. int inheritsched; // 线程的继承性

7. int scope; // 线程的作用域

8. size_t guardsize; // 线程栈末尾的警戒缓冲区大小

9. int stackaddr_set; // 线程的栈设置

10. void* stackaddr; // 线程栈的位置

11. size_t stacksize; // 线程栈的大小

12. } pthread_attr_t;

pthread_attr_init
#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
Compile and link with -pthread.
功能：初始化一个线程属性对象
参数：@attr 线程属性结构体指针变量
返回值：0 - 成功，非0 - 失败

pthread_attr_destroy
#include <pthread.h>
int pthread_attr_destroy(pthread_attr_t *attr);
Compile and link with -pthread.
功能：销毁一个线程属性对象
参数：@attr 线程属性结构体指针变量
返回值：0 - 成功，非0 - 失败

2.【线程的分离状态】
线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状态启动。
可以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。可以使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。

pthread_attr_getdetachstate
#include<pthread.h>
int pthread_attr_getdetachstate(pthread_attr_t *attr,int detachstate);
Compile and link with -pthread.
功能：获取线程的分离状态属性
参数：
@attr 线程属性变量
@detachstate 线程的分离状态属性
返回值：0 - 成功，非0 - 失败

pthread_attr_setdetachstate
#include<pthread.h>
int pthread_attr_setdetachstate(pthread_attr_t *attr,int *detachstate);
Compile and link with -pthread.
功能：获取线程的分离状态属性
参数：
@attr 线程属性变量
@detachstate 线程的分离状态属性
返回值：0 - 成功，非0 - 失败

/* 举例验证 - 涉及线程的继承、调度、参数 */
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <sched.h>
void *child_thread(void *arg)
{int policy = 0;int max_priority = 0,min_priority = 0;struct sched_param param;pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED);pthread_attr_getinheritsched(&attr,&policy);if(policy == PTHREAD_EXPLICIT_SCHED){printf("Inheritsched:PTHREAD_EXPLICIT_SCHED\n");}if(policy == PTHREAD_INHERIT_SCHED){printf("Inheritsched:PTHREAD_INHERIT_SCHED\n");}pthread_attr_setschedpolicy(&attr,SCHED_RR);pthread_attr_getschedpolicy(&attr,&policy);if(policy == SCHED_FIFO){printf("Schedpolicy:SCHED_FIFO\n");}if(policy == SCHED_RR){printf("Schedpolicy:SCHED_RR\n");}if(policy == SCHED_OTHER){printf("Schedpolicy:SCHED_OTHER\n");}max_priority = sched_get_priority_max(policy);min_priority = sched_get_priority_min(policy);printf("Maxpriority:%u\n",max_priority);printf("Minpriority:%u\n",min_priority);param.sched_priority = max_priority;pthread_attr_setschedparam(&attr,¶m);printf("sched_priority:%u\n",param.sched_priority);pthread_attr_destroy(&attr);
}int main(int argc,char *argv[ ])
{pthread_t child_thread_id;pthread_create(&child_thread_id,NULL,child_thread,NULL);pthread_join(child_thread_id,NULL);return 0;
}编译：
gcc pthread.c -o pthread -pthread运行结果：
Inheritsched:PTHREAD_EXPLICIT_SCHED
Schedpolicy:SCHED_RR
Maxpriority:99
Minpriority:1
sched_priority:99

3.    线程的继承性：

函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设
置和得到线程的继承性!

#include <pthread.h>
int pthread_attr_getinheritsched(const pthread_attr_t *attr,int *inheritsched);
int pthread_attr_setinheritsched(pthread_attr_t *attr,int inheritsched);
参数：
attr                线程属性变量
inheritsched     线程的继承性
若成功返回0，若失败返回-1。

请注意：
继承性决定调度的参数是从创建的进程中继承还是使用在 
schedpolicy和schedparam属性中显式设置的调度信息。           

线程没有默认的继承值设置，所以如果关心线程的调度策略和参数，
只能手动设置！

可设置参数：
PTHREAD_INHERIT_SCHED： 新的线程继承创建线程的策略和参数！
PTHREAD_EXPLICIT_SCHED：新的线程继承策略和参数来自于
schedpolicy和schedparam属性中显式
设置的调度信息！

>>>>>:    下面补充线程调度策略和调度参数：
<1>.调度策略：

函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用
来设置和得到线程的调度策略。

int pthread_attr_getschedpolicy(const pthread_attr_t *, int * policy)
int pthread_attr_setschedpolicy(pthread_attr_*, int policy)
参数：
attr            线程属性变量
policy        调度策略   
若成功返回0，若失败返回-1。

所谓调度策略也就是我们之前在OS中所学过的那些调度算法：
SCHED_FIFO    ：先进先出
SCHED_RR       ：轮转法
SCHED_OTHER    ：其他方法

SCHED_OTHER是不支持优先级使用的,而SCHED_FIFO和SCHED_RR
支持优先级的使用,他们分别为1和99,数值越大优先级越高.

注意：
> 此处的SCHED_FIFO是允许被高优先级抢占的！
> 也就是有高优先级的必须先运行
> SCHED_RR是设置一个时间片
> 当有SCHED_FIFO或SCHED_RR策赂的线程在一个条件变量
上等持或等持加锁同一个互斥量时，它们将以优先级顺序被唤
醒。即，如果一个低优先级的SCHED_FIFO线程和一个高优先
织的SCHED_FIFO线程都在等待锁相同的互斥且，则当互斥量
被解锁时，高优先级线程将总是被首先解除阻塞。

<2>.调度参数：

函数pthread_attr_getschedparam 和pthread_attr_setschedparam分别
用来设置和得到线程的调度参数。



int pthread_attr_getschedparam(const pthread_attr_t *,struct
sched_param *);
int pthread_attr_setschedparam(pthread_attr_t *,const struct
sched_param *);
参数：
attr            线程变量属性
param        sched_parm 结构体
若成功返回0，若失败返回-1。

/usr/include /bits/sched.h
struct sched_param
{
int sched_priority;    //!> 参数的本质就是优先级
};
注意：大的权值对应高的优先级!
系统支持的最大和最小的优先级值可以用函数：
sched_get_priority_max和sched_get_priority_min得到！

#include <pthread.h>
int sched_get_priority_max( int policy );
int sched_get_priority_min( int policy );
参数：max_：    系统支持的优先级的最小值
min_ ：    系统支持的优先级的最大值

使用：max_ = sched_get_priority_max( policy );
min_ = sched_get_priority_min( policy );
注意参数是policy调用策略，也就是说对于不同的策略的值是不
一样的！

附录：来自
http://www.yuanma.org/data/2006/0823/article_1392.htm
policy = SCHED_OTHER
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

3.    线程的作用域：

函数pthread_attr_setscope和pthread_attr_getscope分别
用来设置和得到线程的作用域。       
#include <pthread.h>   
int    pthread_attr_getscope( const pthread_attr_t * attr, int * scope );
int pthread_attr_setscope( pthread_attr_t*, int scope );
参数：
attr               线程属性变量
scope         线程的作用域       
若成功返回0，若失败返回-1。

作用域控制线程是否在进程内或在系统级上竞争资源，可能的值是
PTHREAD_SCOPE_PROCESS（进程内竞争资源）
PTHREAD_SCOPE_SYSTEM   （系统级竞争资源）。

4.    线程堆栈的大小

函数pthread_attr_setstackaddr和pthread_attr_getstackaddr分别用来设置和得
到线程堆栈的位置。

int pthread_attr_getstacksize(const pthread_attr_t *,size_t * stacksize);
int pthread_attr_setstacksize(pthread_attr_t *attr ,size_t *stacksize);
参数：attr                线程属性变量
stacksize        堆栈大小
若成功返回0，若失败返回-1。           

5.    线程堆栈的地址           

#include <pthread.h>
int pthread_attr_getstackaddr(const pthread_attr_t *attr,void **stackaddf);
int pthread_attr_setstackaddr(pthread_attr_t *attr,void *stackaddr);
参数：attr               线程属性变量
stackaddr     堆栈地址           
若成功返回0，若失败返回-1。

注意：pthread_attr_getstackaddr已经过期，现在使用的是：pthread_attr_getstack

6.    警戒缓冲区

函数pthread_attr_getguardsize和pthread_attr_setguardsize分别用来设置和得
到线程栈末尾的警戒缓冲区大小。

#include <pthread.h>                   
int pthread_attr_getguardsize(const pthread_attr_t *restrict attr,size_t *restrict
guardsize);
int pthread_attr_setguardsize(pthread_attr_t *attr ,size_t *guardsize);
若成功返回0，若失败返回-1。

值得注意：
线程属性guardsize控制着线程栈末尾之后以避免栈溢出的扩展内存
大小。这个属性默认设置为PAGESIZE个字节。可以把guardsize线
程属性设为0，从而不允许属性的这种特征行为发生：在这种情况
下不会提供警戒缓存区。同样地，如果对线程属性stackaddr作了
修改，系统就会认为我们会自己管理栈，并使警戒栈缓冲区机制无
效，等同于把guardsize线程属性设为0。