线程的属性有:分离状态、调度策略和参数、作用域、栈尺寸、栈地址、优先级。
线程的属性定义为联合体
union pthread_attr_t{
char __size[__SIZEOF_PTHREAD_ATTR_T];
long int __align;
};
char __size[__SIZEOF_PTHREAD_ATTR_T]
字符数组,大小为__SIZEOF_PTHREAD_ATTR_T,用于存储属性值
long int __align
对齐成员,确保结构体的对齐方式符合要求
获取属性结构体值
int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);
用于获取线程thread的属性,并将这些属性存储在attr指向的pthread_attr_t结构体中,当获得的属性结构体变量不再需要的时候,应该用函数pthread_attr_destroy进行销毁。
使用该函数需要定义宏#define _GNU_SOURCE。
在创建线程时,若属性结构体指针是NULL,则线程是默认属性,即非分离,大小为1MB的堆栈,与父进程有同样级别的优先级。若要创建非默认属性的线程,在创建线程之前要用函数pthread_attr_init来初始化一个线程属性结构体。
初始化属性结构体值
int pthread_attr_init(pthread_attr_t *attr);
attr为指向线程属性结构体的指针,如果初始化成功,返回0,否则返回一个错误码。使用pthread_attr_init初始化线程属性,使用完(即传入pthread_create)后需要使用pthread_attr_destroy进行销毁,从而释放相关资源。
销毁属性结构体值
int pthread_attr_destroy(pthread_attr_t *attr);
attr为指向线程属性结构体的指针,如果函数成功,返回0,否则返回一个错误码。
设置线程的分离状态属性
int pthread_attr_setdetachstate(pthread_attr_t * attr, int detachstate);
attr为指向线程属性结构体的指针;detachstate是要设置的分离状态值,可以取值PTHREAD_CREATE_DETACHED或PTHREAD_CREATE_JOINABLE。
eg. 创建一个可分离线程
分离线程是指线程在完成执行后,其资源会被自动释放,主线程无需显式地调用pthread_join来回收这些资源,这种模式适合那些在运行后不需要进一步管理的线程任务,减少了对线程管理的需求,但也意味着主线程不能获取分离线程的返回值或状态。
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
void *thfunc(void *arg){
printf("sub thread is running\n");
return NULL;
}
int main(int argc,char *argv[]){
pthread_t tidp;
pthread_attr_t thread_attr; // 线程属性对象
int ret;
// 初始化线程属性对象
ret=pthread_attr_init(&thread_attr);
if(ret){
printf("pthread_attr_init failed: %d\n",ret);
return -1;
}
// 设置线程为分离状态 表示线程结束后系统将自动释放资源
ret=pthread_attr_setdetachstate(&thread_attr,PTHREAD_CREATE_DETACHED);
if(ret){
printf("pthread_attr_setdetachstate failed: %d\n",ret);
return -2;
}
// 创建线程
ret=pthread_create(&tidp,&thread_attr,thfunc,NULL);
if(ret){
printf("pthread_create failed: %d\n",ret);
return -3;
}
// 释放线程属性对象的资源
pthread_attr_destroy(&thread_attr);
printf("main thread will exit\n");
sleep(1); // 让主线程挂起1s 让子线程有机会执行
return 0;
}
eg. 创建一个可分离线程,且主线程先退出
上例中,在主线程中设置sleep,从而让子线程完整执行。但如果子线程执行的时间长,则sleep的设置比较麻烦。有没有什么方法可以不设置sleep,也能让子线程完整执行呢?
对于可连接线程,主线程可以用pthread_join函数等待子线程结束。
而对于可分离线程,并没有这样的函数,但可以采用这样的方法:让主线程退出而进程不退出,一直等到子线程退出了,进程才退出。
线程终止自身运行
void pthread_exit(void *retval);
pthread_exit是一个用于终止调用线程的函数,它可以传递一个返回值给其他线程,通常用于线程之间的协作或线程的退出状态传递。retval是指向线程退出时返回值的指针。这个值可以被其他线程通过调用pthread_join函数来获取。线程可以通过将retval设置为NULL来表示没有返回值。
#include <pthread.h>
#include <stdio.h>
void *thfunc(void *arg){
printf("sub thread is running\n");
return NULL;
}
int main(int argc,char *argv[]){
pthread_t tidp;
pthread_attr_t thread_attr; // 线程属性对象
int ret;
// 初始化线程属性对象
ret=pthread_attr_init(&thread_attr);
if(ret){
printf("pthread_attr_init failed: %d\n",ret);
return -1;
}
// 设置线程为分离状态 表示线程结束后系统将自动释放资源
ret=pthread_attr_setdetachstate(&thread_attr,PTHREAD_CREATE_DETACHED);
if(ret){
printf("pthread_attr_setdetachstate failed: %d\n",ret);
return -2;
}
// 创建线程
ret=pthread_create(&tidp,&thread_attr,thfunc,NULL);
if(ret){
printf("pthread_create failed: %d\n",ret);
return -3;
}
// 释放线程属性对象的资源
pthread_attr_destroy(&thread_attr);
printf("main thread will exit\n");
pthread_exit(NULL); // 主线程退出,但进程不会此刻退出,下面的语句不会执行
printf("main thread has exited, this line will not run\n");
return 0;
}
在主线程中调用pthread_exit仅终止主线程,但不会结束整个进程。其他线程会继续执行,直到它们各自终止。
获取线程分离状态属性
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
attr为属性结构体指针,detachstate返回分离状态。
eg. 获取默认创建的线程的分离状态属性
#include <pthread.h>
#include <stdio.h>
void *thfunc(void *arg){
printf("sub thread is running\n");
return NULL;
}
int main(int argc, char *argv[]) {
pthread_t tidp;
pthread_attr_t thread_attr; // 线程属性对象
int ret;
int detachstate; // 分离状态
// 初始化线程属性对象
ret = pthread_attr_init(&thread_attr);
if (ret) {
printf("pthread_attr_init failed: %d\n", ret);
return -1;
}
// 创建线程
ret = pthread_create(&tidp, &thread_attr, thfunc, NULL);
if (ret) {
printf("pthread_create failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -2;
}
// 从属性结构值中获取分离状态属性
ret = pthread_attr_getdetachstate(&thread_attr, &detachstate);
if (ret) {
printf("pthread_attr_getdetachstate failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -3;
}
// 打印分离状态属性
printf("thread's detachstate attributes:\n");
printf("detach state is = ");
if (detachstate == PTHREAD_CREATE_DETACHED) {
printf("PTHREAD_CREATE_DETACHED\n");
} else if (detachstate == PTHREAD_CREATE_JOINABLE) {
printf("PTHREAD_CREATE_JOINABLE\n");
} else {
printf("unknown\n");
}
// 释放线程属性对象的资源
pthread_attr_destroy(&thread_attr);
printf("main thread will exit\n");
// 等待新线程结束
pthread_join(tidp, NULL);
return 0;
}
默认创建的线程是可连接线程,其分离状态属性可连接。
获取线程的当前属性
int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);
thread是要查询的线程标识符。attr为属性结构体指针。
eg. 把可连接线程转为可分离线程
#include <pthread.h>
#include <stdio.h>
void *thfunc(void *arg) {
printf("sub thread is running\n");
return NULL;
}
int main(int argc, char *argv[]) {
pthread_t tidp;
pthread_attr_t thread_attr;
int ret;
int detachstate;
// 初始化线程属性对象
ret = pthread_attr_init(&thread_attr);
if (ret) {
printf("pthread_attr_init failed: %d\n",ret);
return -1;
}
// 创建线程
ret = pthread_create(&tidp, &thread_attr, thfunc, NULL);
if (ret) {
printf("pthread_create failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -2;
}
// 从属性结构值中获取分离状态属性
ret = pthread_attr_getdetachstate(&thread_attr, &detachstate);
if (ret) {
printf("pthread_attr_getdetachstate failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -3;
}
// 打印分离状态属性
printf("thread's detachstate attributes:\n");
printf("detach state is = ");
if (detachstate == PTHREAD_CREATE_DETACHED) {
printf("PTHREAD_CREATE_DETACHED\n");
} else if (detachstate == PTHREAD_CREATE_JOINABLE) {
printf("PTHREAD_CREATE_JOINABLE\n");
} else {
printf("unknown\n");
}
// 设置线程为分离状态
ret = pthread_detach(tidp);
if (ret) {
printf("pthread_detach failed: %d\n", ret);
return -4;
}
// 尝试获取线程的当前属性
ret=pthread_getattr_np(tidp,&thread_attr);
if (ret) {
printf("pthread_getattr_np failed: %d\n", ret);
return -5;
}
// 从属性结构值中获取分离状态属性
ret = pthread_attr_getdetachstate(&thread_attr, &detachstate);
if (ret) {
printf("pthread_attr_getdetachstate failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -3;
}
// 打印分离状态属性
printf("thread's detachstate attributes:\n");
printf("detach state is = ");
if (detachstate == PTHREAD_CREATE_DETACHED) {
printf("PTHREAD_CREATE_DETACHED\n");
} else if (detachstate == PTHREAD_CREATE_JOINABLE) {
printf("PTHREAD_CREATE_JOINABLE\n");
} else {
printf("unknown\n");
}
// 释放线程属性对象的资源
pthread_attr_destroy(&thread_attr);
printf("main thread will exit\n");
// 主线程退出 进程不会马上结束
pthread_exit(NULL);
return 0;
}
获取线程栈尺寸属性
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
attr指向属性结构体,stacksize用于获得栈尺寸(单位是字节),它指向size_t类型的变量。
eg. 获得线程默认栈尺寸大小和最小尺寸
#include <pthread.h>
#include <stdio.h>
#include <bits/local_lim.h> // PTHREAD_STACK_MIN
void *thfunc(void *arg) {
printf("Sub thread is running\n");
return NULL;
}
int main(int argc, char *argv[]) {
pthread_t tidp;
pthread_attr_t thread_attr;
int ret;
size_t stack_size; // 线程栈大小
// 初始化线程属性对象
ret = pthread_attr_init(&thread_attr);
if (ret) {
printf("pthread_attr_init failed: %d\n", ret);
return -1;
}
// 从属性结构值中获取栈属性
ret = pthread_attr_getstacksize(&thread_attr, &stack_size);
if (ret) {
printf("pthread_attr_getstacksize failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -2;
}
// 打印栈属性
printf("Default stack size is %zu bytes; minimum is %d bytes.\n", stack_size, PTHREAD_STACK_MIN);
// 创建线程
ret = pthread_create(&tidp, &thread_attr, thfunc, NULL);
if (ret) {
printf("pthread_create failed: %d\n", ret);
pthread_attr_destroy(&thread_attr);
return -3;
}
// 释放线程属性对象的资源
pthread_attr_destroy(&thread_attr);
// 等待新线程结束
pthread_join(tidp, NULL);
return 0;
}
调度策略
调度策略是线程的一个重要属性。某个线程肯定有一种策略来调度它。进程中有了多个线程后,就要管理这些线程如何去占用CPU,这就是线程调度。
理解实时和非实时的概念是深入掌握线程调度的基础。实时系统指的是系统必须在严格的时间限制内完成特定任务。它们的主要特点是可预测性和时间敏感性。实时系统的响应时间是非常关键的,超出规定时间会导致系统失败或性能严重下降。非实时系统并不要求在严格的时间限制内完成任务。它们通常关注系统的吞吐量和效率,而不是特定任务的时间约束。
Linux虽然是个非实时操作系统,但其线程也有实时和分时之分,具体的调度策略可以分为3种:SCHED_OTHER(分时调度策略)、SCHED_FIFO(先来先服务调度策略)、SCHED_RR(实时的分时调度策略)。
SCHED_OTHER
SCHED_OTHER表示分时调度策略(也可称作轮转策略),是一种非实时调度策略,系统会为每个线程分配一段运行时间,称为时间片。该调度策略是不支持优先级的,如果我们去获取该调度策略下的最高和最低优先级,可以发现都是0。
SCHED_FIFO
SCHED_FIFO表示先来先服务调度策略,是一种实时调度策略,支持优先级抢占(真实支持优先级,因此可以算一种实时调度策略)。在SCHED_FIFO策略下,CPU让一个先来的线程执行完再调度下一个线程,顺序就是按照创建线程的先后。线程一旦占用CPU则一直运行,直到有更高优先级任务到达或自己放弃CPU。
SHCED_RR
SHCED_RR表示时间片轮转(轮询)调度策略,但支持优先级抢占,因此也是一种实时调度策略。SHCED_RR策略下,CPU会分配给每个线程一个特定的时间片,当线程的时间片用完,系统将重新分配时间片,并将线程置于实时线程就绪队列的尾部,这样保证了所有具有相同优先级的线程能够被公平地调度。
获取某种策略下可设置的最低和最高优先级
int sched_get_priority_min(int policy);
int sched_get_priority_max(int policy);
policy是调度策略。
eg. 获取三种策略下可设置的最低和最高优先级
#include <stdio.h>
#include <pthread.h>
int main(int argc,char* argv[]){
printf("Valid priority range for SCHED_OTHER: %d - %d\n",
sched_get_priority_min(SCHED_OTHER),sched_get_priority_max(SCHED_OTHER));
printf("Valid priority range for SCHED_FIFO: %d - %d\n",
sched_get_priority_min(SCHED_FIFO),sched_get_priority_max(SCHED_FIFO));
printf("Valid priority range for SCHED_RR: %d - %d\n",
sched_get_priority_min(SCHED_RR),sched_get_priority_max(SCHED_RR));
}