线程的属性（Linux C/C++笔记）

最新推荐文章于 2024-09-11 15:28:58 发布

Wendy_robot

最新推荐文章于 2024-09-11 15:28:58 发布

阅读量779

点赞数 30

文章标签： c++ 开发语言 linux

本文链接：https://blog.csdn.net/Wendy_robot/article/details/141997984

版权

线程的属性有：分离状态、调度策略和参数、作用域、栈尺寸、栈地址、优先级。

线程的属性定义为联合体

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));
}

Wendy_robot

关注

30
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
线程的属性（Linux C/C++笔记）

线程的属性有：分离状态、调度策略和参数、作用域、栈尺寸、栈地址、优先级。char __size[__SIZEOF_PTHREAD_ATTR_T]字符数组，大小为__SIZEOF_PTHREAD_ATTR_T，用于存储属性值对齐成员，确保结构体的对齐方式符合要求用于获取线程thread的属性，并将这些属性存储在attr指向的pthread_attr_t结构体中，当获得的属性结构体变量不再需要的时候，应该用函数pthread_attr_destroy进行销毁。使用该函数需要定义宏#define
复制链接

扫一扫