Linux多线程实践（三）线程的基本属性设置API

POSIX 线程库定义了线程属性对象 pthread_attr_t ，它封装了线程的创建者可以访问和修改的线程属性。主要包括如下属性：

1. 作用域（scope）

2. 栈尺寸（stack size）

3. 栈地址（stack address）

4. 优先级（priority）

5. 分离的状态（detached state）

6. 调度策略和参数（scheduling policy and parameters）

 线程属性对象可以与一个线程或多个线程相关联。当使用线程属性对象时，它是对线程和线程组行为的配置。使用属性对象的所有线程都将具有由属性对象所定义的所有属 性。虽然它们共享属性对象，但它们维护各自独立的线程 ID 和寄存器。

初始化/销毁线程属性

[cpp]  view plain  copy

1. int pthread_attr_init(pthread_attr_t *attr);    
2. int pthread_attr_destroy(pthread_attr_t *attr);    

线程分离属性

[cpp]  view plain  copy

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

线程栈大小

[cpp]  view plain  copy

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

一般情况下该值我们设置为0，使用系统默认设置的线程栈大小，否则可能会引起程序的可移植性的问题

线程栈溢出保护区大小

[cpp]  view plain  copy

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

guardsize意思是如果我们使用线程栈超过了设定大小之后，系统还会使用部分扩展内存来防止栈溢出。而这部分扩展内存大小就是guardsize. 不过如果自己修改了栈分配位置的话，那么这个选项失效，效果相当于将guardsize设置为0.

每个线程都存在自己的堆栈，如果这些堆栈是相连的话，访问超过自己的堆栈的话那么可能会修改到其他线程的堆栈。 如果我们设置了guardsize的话，线程堆栈会多开辟guarszie大小的内存，当访问到这块内存时会触发SIGSEGV信号。

线程竞争范围(进程范围内的竞争　or　系统范围内的竞争)

[cpp]  view plain  copy

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

线程可以在两种竞争域内竞争资源：

1. 进程域（process scope）：与同一进程内的其他线程

2. 系统域（system scope）：与系统中的所有线程

作用域属性描述特定线程将与哪些线程竞争资源。一个具有系统域的线程将与整个系 统中所有具有系统域的线程按照优先级竞争处理器资源，进行调度。

线程调度策略

[cpp]  view plain  copy

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

进程的调度策略和优先级属于主线程，换句话说就是设置进程的调度策略和优先级只 会影响主线程的调度策略和优先级，而不会改变对等线程的调度策略和优先级（注这句话不完全正确）。每个对等线程可以拥有它自己的独立于主线程的调度策略和优先级。

在 Linux 系统中，进程有三种调度策略：SCHED_FIFO(先进先出调度策略)、SCHED_RR(时间片轮转调度算法) 和 SCHED_OTHER（线程一旦开始运行，直到被抢占或者直到线程阻塞或停止为止），线程也不例外，也具有这三种策略。

线程继承的调度策略

[cpp]  view plain  copy

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

在 pthread 库中，提供了一个函数，用来设置被创建的线程的调度属性：是从创建者线 程继承调度属性（调度策略和优先级），还是从属性对象设置调度属性。该函数就是：

[cpp]  view plain  copy

1. int pthread_attr_setinheritsched (pthread_attr_t *   attr, int    inherit) 其中，inherit 的值为下列值中的其一：  
2. enum  
3. {  
4. PTHREAD_INHERIT_SCHED, //线程调度属性从创建者线程继承  
5.  PTHREAD_EXPLICIT_SCHED //线程调度属性设置为 attr 设置的属性  
6. };  

如果在创建新的线程时，调用该函数将参数设置为 PTHREAD_INHERIT_SCHED 时，那么当修改进程的优先级时，该进程中继承这个优先级并且还没有改变其优先级的所 有线程也将会跟着改变优先级（也就是刚才那句话部分正确的原因）。

线程调度参数(实际上我们一般只关心一个参数：线程的优先级,默认为0)

[cpp]  view plain  copy

1. int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);    
2. int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);    
3. //sched_param结构体    
4. struct sched_param {    
5.     int sched_priority;     /* Scheduling priority */    
6. };    

线程的并发级别

[cpp]  view plain  copy

1. int pthread_setconcurrency(int new_level);    
2. int pthread_getconcurrency(void);   

说明：并发级别仅在N:M线程模型中有效，设置并发级别，给内核一个提示：表示提供给定级别数量的核心线程来映射用户线程是高效的(仅仅是一个提示)，默认为0, 内核按照默认的方式进行并发；

我们来写一个例子来运用：

[cpp]  view plain  copy

1. /** 查看线程默认属性 **/    
2. void printThreadAttr()    
3. {    
4.     pthread_attr_t attr;    
5.     pthread_attr_init(&attr);    
6.     
7.     int detachstate;    
8.     pthread_attr_getdetachstate(&attr, &detachstate);    
9.     cout << "detach-state: "    
10.          << (detachstate == PTHREAD_CREATE_JOINABLE ?    
11.              "PTHREAD_CREATE_JOINABLE" : "PTHREAD_CREATE_DETACHED")    
12.          << endl;    
13.     
14.     size_t size;    
15.     pthread_attr_getstacksize(&attr, &size);    
16.     cout << "stack-size: " << size << endl;    
17.     
18.     pthread_attr_getguardsize(&attr, &size);    
19.     cout << "guard-size: " << size << endl;    
20.     
21.     int scope;    
22.     pthread_attr_getscope(&attr, &scope);    
23.     cout << "scope: "    
24.          << (scope == PTHREAD_SCOPE_SYSTEM ?    
25.              "PTHREAD_SCOPE_SYSTEM" : "PTHREAD_SCOPE_PROCESS")    
26.          << endl;    
27.     
28.     int policy;    
29.     pthread_attr_getschedpolicy(&attr, &policy);    
30.     cout << "policy: ";    
31.     switch (policy)    
32.     {    
33.     case SCHED_FIFO:    
34.         cout << "SCHED_FIFO";    
35.         break;    
36.     case SCHED_RR:    
37.         cout << "SCHED_RR";    
38.         break;    
39.     case SCHED_OTHER:    
40.         cout << "SCHED_OTHER";    
41.         break;    
42.     default:    
43.         break;    
44.     }    
45.     cout << endl;    
46.     
47.     int inheritsched;    
48.     pthread_attr_getinheritsched(&attr, &inheritsched);    
49.     cout << "inheritsched: "    
50.          << (inheritsched == PTHREAD_INHERIT_SCHED ?    
51.              "PTHREAD_INHERIT_SCHED" : "PTHREAD_INHERIT_SCHED")    
52.          << endl;    
53.     
54.     struct sched_param param;    
55.     pthread_attr_getschedparam(&attr, ¶m);    
56.     cout << "scheduling priority: " << param.sched_priority << endl;    
57.     cout << "concurrency: " << pthread_getconcurrency() << endl;    
58.     pthread_attr_destroy(&attr);    
59. }    

说明:

绑定属性:

  Linux中采用“一对一”的线程机制，也就是一个用户线程对应一个内核线程。绑定属性就是指一个用户线程固定地分配给一个内核线程，因为CPU时间片的调度是面向内核线程（也就是轻量级进程）的，因此具有绑定属性的线程可以保证在需要的时候总有一个内核线程与之对应。而与之对应的非绑定属性就是指用户线程和内核线程的关系不是始终固定的，而是由系统来控制分配的。 

分离属性:

  分离属性是用来决定一个线程以什么样的方式来终止自己。在非分离情况下，当一个线程结束时，它所占用的系统资源并没有被释放，也就是没有真正的终止。只有当pthread_join()函数返回时，创建的线程才能释放自己占用的系统资源。而在分离属性情况下，一个线程结束时立即释放它所占有的系统资源。这里要注意的一点是，如果设置一个线程的分离属性，而这个线程运行又非常快，那么它很可能在pthread_create()函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用。