初始化后使用，使用后还要进行去除初始化！
pthread_attr_init:初始化
pthread_attr_destory:去除初始化
#include<pthread.h>
intpthread_attr_init(pthread_attr_t *attr);
intpthread_attr_destroy(pthread_attr_t*attr);
若成功返回0，若失败返回-1。
pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现
支持的线程所有属性的默认值。
如果pthread_attr_init实现时为属性对象分配了动态内存空间，
pthread_attr_destroy还会用无效的值初始化属性对象，因此如果经
pthread_attr_destroy去除初始化之后的pthread_attr_t结构被
pthread_create函数调用，将会导致其返回错误。
线程属性结构如下：
typedefstruct
{
int detachstate; 线程的分离状态
int schedpolicy; 线程调度策略
structsched_param schedparam; 线程的调度参数
int inheritsched; 线程的继承性
int scope; 线程的作用域
size_t guardsize; 线程栈末尾的警戒缓冲区大小
int stackaddr_set;
void* stackaddr; 线程栈的位置
size_t stacksize; 线程栈的大小
}pthread_attr_t;
下面主要讨论此结构体！！！
2. 分离状态:
线程的分离状态决定一个线程以什么样的方式来终止自己。
我们已经在前面已经知道，在默认情况下线程是非分离状态的，这种情况
下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回
时，创建的线程才算终止，才能释放自己占用的系统资源。
分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，
马上释放系统资源。
通俗的说也就是：我们知道一般我们要等待(pthread_join)一个线程的结束，
主要是想知道它的结束状态，否则等待一般是没有什么意义的！但是if有一
些线程的终止态我们压根就不想知道，那么就可以使用“分离”属性，那么我
们就无须等待管理，只要线程自己结束了，自己释放src就可以咯！这样更
方便！
#include<pthread.h>
intpthread_attr_getdetachstate(const pthread_attr_t * attr, int *detachstate);
intpthread_attr_setdetachstate(pthread_attr_t * attr, intdetachstate);
参数：attr:线程属性变量
detachstate:分离状态属性
若成功返回0，若失败返回-1。
设置的时候可以有两种选择：
<1>.detachstate参数为：PTHREAD_CREATE_DETACHED 分离状态启动
<2>.detachstate参数为：PTHREAD_CREATE_JOINABLE 正常启动线程
3. 线程的继承性：
函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设
置和得到线程的继承性!
#include<pthread.h>
intpthread_attr_getinheritsched(const pthread_attr_t *attr,int*inheritsched);
intpthread_attr_setinheritsched(pthread_attr_t *attr,intinheritsched);
参数：
attr 线程属性变量
inheritsched 线程的继承性
若成功返回0，若失败返回-1。
请注意：
继承性决定调度的参数是从创建的进程中继承还是使用在
schedpolicy和schedparam属性中显式设置的调度信息。
线程没有默认的继承值设置，所以如果关心线程的调度策略和参数，
只能手动设置！
可设置参数：
PTHREAD_INHERIT_SCHED： 新的线程继承创建线程的策略和参数！
PTHREAD_EXPLICIT_SCHED：新的线程继承策略和参数来自于
schedpolicy和schedparam属性中显式
设置的调度信息！
>>>>>: 下面补充线程调度策略和调度参数：
<1>.调度策略：
函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用
来设置和得到线程的调度策略。
intpthread_attr_getschedpolicy(const pthread_attr_t *, int *policy)
intpthread_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分别
用来设置和得到线程的调度参数。
intpthread_attr_getschedparam(const pthread_attr_t *,struct
sched_param*);
intpthread_attr_setschedparam(pthread_attr_t *,const struct
sched_param*);
参数：
attr 线程变量属性
param sched_parm结构体
若成功返回0，若失败返回-1。
/usr/include/bits/sched.h
structsched_param
{
intsched_priority; //!> 参数的本质就是优先级
};
注意：大的权值对应高的优先级!
系统支持的最大和最小的优先级值可以用函数：
sched_get_priority_max和sched_get_priority_min得到！
#include<pthread.h>
intsched_get_priority_max( int policy );
intsched_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
ShowSCHED_FIFO of priority
max_priority= 99
min_priority= 1
ShowSCHED_RR of priority
max_priority= 99
min_priority= 1
Showpriority 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);
intpthread_attr_setscope( pthread_attr_t*, int scope );
参数：
attr 线程属性变量
scope 线程的作用域
若成功返回0，若失败返回-1。
作用域控制线程是否在进程内或在系统级上竞争资源，可能的值是
PTHREAD_SCOPE_PROCESS（进程内竞争资源）
PTHREAD_SCOPE_SYSTEM （系统级竞争资源）。
4. 线程堆栈的大小
函数pthread_attr_setstackaddr和pthread_attr_getstackaddr分别用来设置和得
到线程堆栈的位置。
intpthread_attr_getstacksize(const pthread_attr_t *,size_t *stacksize);
intpthread_attr_setstacksize(pthread_attr_t *attr ,size_t*stacksize);
参数：attr 线程属性变量
stacksize 堆栈大小
若成功返回0，若失败返回-1。
5. 线程堆栈的地址
#include<pthread.h>
intpthread_attr_getstackaddr(const pthread_attr_t *attr,void**stackaddf);
intpthread_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>
intpthread_attr_getguardsize(const pthread_attr_t *restrictattr,size_t *restrict
guardsize);
intpthread_attr_setguardsize(pthread_attr_t *attr ,size_t*guardsize);
若成功返回0，若失败返回-1。
值得注意：
线程属性guardsize控制着线程栈末尾之后以避免栈溢出的扩展内存
大小。这个属性默认设置为PAGESIZE个字节。可以把guardsize线
程属性设为0，从而不允许属性的这种特征行为发生：在这种情况
下不会提供警戒缓存区。同样地，如果对线程属性stackaddr作了
修改，系统就会认为我们会自己管理栈，并使警戒栈缓冲区机制无
效，等同于把guardsize线程属性设为0。
1.detach实例：
//!> detach
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void * entrance( void * arg )
{
int get_attr_int;
pthread_attr_t attr;
printf("子进程创建OK， ID == %d\n",(unsigned)pthread_self());
if(pthread_attr_getdetachstate( &attr,&get_attr_int ) != 0 )
{
printf("获取属性失败...\n");
exit(EXIT_FAILURE );
}
if(PTHREAD_CREATE_DETACHED == get_attr_int) //!> 设置分离OK
{
printf("我是被分离的线程...\n");
}
}
int main( int argc, char ** argv )
{
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init( &attr); //!> 初始化属性
if(pthread_attr_setdetachstate( &attr,PTHREAD_CREATE_DETACHED ) != 0 )
{
printf("设置属性失败...\n");
exit(EXIT_FAILURE );
}
//!> 设置成分离
if(pthread_create( &tid, &attr,entrance, NULL ) !=0) //!> 按照此属性创建线程
{
printf("创建线程失败...\n");
exit(EXIT_FAILURE );
}
else
{
printf("创建OK... \n");
}
//!>pthread_join(tid); //!> 注意此处的join是不需要的！！！！！！！
pthread_attr_destroy( &attr); //!> 去除属性
sleep( 2); //!> 注意此处要有一个释放CPU处理，不然看不到子线程输出
return0;
}
运行结果：
创建OK...
子进程创建OK， ID== 1635653376
我是被分离的线程...
2.继承、优先级、调度策略实例
//!> 继承、线程优先级、调度策略
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void * entrance( void * arg )
{
int policy; //!> 调度策略
int max_; //!> 最大优先级
int min_; //!> 最小优先级
structsched_param param; //!> 参数
pthread_attr_t attr; //!> 属性
pthread_attr_init( &attr); //!> 初始化
//!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//!> 下面设置继承性
pthread_attr_setinheritsched( &attr,PTHREAD_EXPLICIT_SCHED );
//!> 设置继承性
pthread_attr_getinheritsched( &attr,&policy );
//!> 得到i继承属性
if(PTHREAD_EXPLICIT_SCHED == policy )
{
printf("继承属性是：PTHREAD_EXPLICIT_SCHED\n");
}
else if(PTHREAD_INHERIT_SCHED == policy )
{
printf("继承属性是：PTHREAD_INHERIT_SCHED\n");
}
else
{
printf("继承属性Error...\n");
exit(EXIT_FAILURE );
}
//!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//!> 下面设置调度策略
pthread_attr_setschedpolicy( &attr, SCHED_RR); //!> 设置轮转法
pthread_attr_getschedpolicy( &attr,&policy); //!> 获得...
if(SCHED_FIFO == policy )
{
printf("调度算法:SCHED_FIFO\n");
}
else if(SCHED_RR == policy )
{
printf("调度算法:SCHED_RR\n");
}
else if(SCHED_OTHER == policy )
{
printf("调度算法:SCHED_OTHER\n");
}
else
{
printf("调度算法Error....\n");
exit(EXIT_FAILURE );
}
//!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//!> 下面优先级设置
max_ =sched_get_priority_max( policy); //!> 得到系统最大优先级值
min_ =sched_get_priority_min( policy); //!> 得到系统最小优先级值
printf("系统最大优先级值： %d \n", max_);
printf("系统最小优先级值： %d \n", min_);
param.sched_priority = max_;
pthread_attr_setschedparam( &attr,¶m); //!> 设置param
pthread_attr_getschedparam( &attr,¶m); //!> 获得param
printf("优先级数== %u\n", param.sched_priority);
pthread_attr_destroy( &attr );
}
int main( int argc, char ** argv )
{
pthread_t tid;
pthread_create( &tid, NULL, entrance, NULL );
pthread_join( tid, NULL); //!> 默认是非分离状态，所以要join
return0;
}
3.作用域、stack大小及地址、警戒缓冲区实例
//!> 作用域、stack大小及地址、警戒缓冲区 实例
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/types.h>
void * entrance( void * arg )
{
pthread_attr_t attr;
int scope; //!> 作用域
size_t stack_size; //!> 栈大小
void * stack_addr; //!> 栈地址
size_t guardsize; //!> 警戒缓冲区大小
pthread_attr_init( &attr );
pthread_attr_getscope( &attr,&scope); //!> 得到scope
if(PTHREAD_SCOPE_PROCESS == scope )
{
printf("Scope == PTHREAD_SCOPE_PROCESS\n");
}
else if(PTHREAD_SCOPE_SYSTEM == scope )
{
printf("Scope == PTHREAD_SCOPE_SYSTEM\n");
}
else
{
printf("Scope Error...");
exit(EXIT_FAILURE );
}
pthread_attr_getstacksize( &attr,&stack_size); //!> 得到栈大小
printf("Stack Size == %d \n", (int)stack_size);
pthread_attr_getstackaddr( &attr,&stack_addr); //!> 得到栈地址
printf("Stack address == %s \n", ( char * )stack_addr );
pthread_attr_getguardsize( &attr,&guardsize); //!> 得到警戒区大小
printf("Guardsize == %d\n", (int)guardsize);
pthread_attr_destroy( &attr );
}
int main( int argc, char ** argv )
{
pthread_t tid;
if(pthread_create( &tid, NULL, entrance, NULL ) != 0)
{
printf("创建线程失败...\n");
exit(EXIT_FAILURE );
}
pthread_join( tid, NULL );
return0;
}
