Qt5.12实战之线程属性使用

最新推荐文章于 2024-07-18 14:38:36 发布

自由软件开发者

最新推荐文章于 2024-07-18 14:38:36 发布

阅读量313

点赞数

CC 4.0 BY-SA版权

分类专栏： QT编程文章标签：算法 jvm java

本文链接：https://blog.youkuaiyun.com/fittec/article/details/130318546

QT编程专栏收录该内容

148 篇文章

订阅专栏

本文展示了如何在C语言中使用POSIX线程库（pthread）进行线程创建、设置线程属性，包括线程的分离状态、调度策略、堆栈大小等，并演示了如何获取和设置线程的优先级以及线程返回值的处理。同时，还涉及到线程间共享数据和线程同步的概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.声明线程属性对象

pthread_attr_t mThreadAttr;//线程属性结构

2.初始化线程属性对象

//初始化线程属性
    int initRet = pthread_attr_init(&mThreadAttr);//因为参数是指针,所以传入地址

3.使用线程属性设置线程分离状态

//设置线程分离状态,成功返回0,其它失败
        int x = pthread_attr_setdetachstate(&mThreadAttr,PTHREAD_CREATE_DETACHED);

4.创建分离线程

 //创建分离线程
            result = pthread_create(&tid,//线程id
                                    &mThreadAttr,//线程属性
                                    thread_func_detach,//线程函数
                                    NULL);//线程函数参数

5.取得线程属性结构对象

 int s= pthread_getattr_np(pthread_self(),&tmpAttr);

6.获取当前线程分离状态

int nState=-1;
    s=pthread_attr_getdetachstate(&tmpAttr,&nState);

7.释放线程属性占用资源

pthread_attr_destroy(&tmpAttr);

8.分离线程函数实现代码如下:

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *thread_func_detach(void *arg)
{
    printf("thread_func_detach:%s\n","这是一个与主线程分离,独立运行的线程,会自动清理内存");
    pthread_attr_t tmpAttr;

    int s= pthread_getattr_np(pthread_self(),&tmpAttr);
    if(s!=0){
        printf("%s\n","pthread_getattr_np fail");
    }
    int nState=-1;
    s=pthread_attr_getdetachstate(&tmpAttr,&nState);
    if(s!=0){
        printf("%s\n","pthread_attr_getdetachstate fail");
    }
    printf("pthread_attr_getdetachstate:%s\n",nState==PTHREAD_CREATE_DETACHED ? "PTHREAD_CREATE_DETACHED" : (nState==PTHREAD_CREATE_JOINABLE?"":"UNKNOW"));
    pthread_attr_destroy(&tmpAttr);
    return (void*)0;
}

获取线程堆栈大小及分离线程代码如下:

void *thread_func_attr_test(void *arg)
{
    printf("thread_func_attr_test\n");
    int dtype=-1;
    pthread_attr_t t_attr;
    int n = pthread_getattr_np(pthread_self(),&t_attr);
    if(n){printf("%s\n","pthread_getattr_np faile");}
    n= pthread_attr_getdetachstate(&t_attr,&dtype);
    if(n){printf("%s\n","pthread_attr_getdetachstate faile");}
    printf("dtype:%s\n",
           dtype==PTHREAD_CREATE_JOINABLE?"PTHREAD_CREATE_JOINABLE"
                                            :(dtype==PTHREAD_CREATE_DETACHED?
                                                   "PTHREAD_CREATE_DETACHED":"unknow"));
    size_t _stack_size;
    n=pthread_attr_getstacksize(&t_attr,&_stack_size);
    if(n){printf("%s\n","pthread_attr_getstacksize faile");}
    printf("stack_size:%d\n",_stack_size);
    pthread_detach(pthread_self());//detached thread from main thread

    n=pthread_getattr_np(pthread_self(),&t_attr);
    if(n){printf("%s\n","pthread_getattr_np faile");}
    n= pthread_attr_getdetachstate(&t_attr,&dtype);
    if(n){printf("%s\n","pthread_attr_getdetachstate faile");}
    printf("dtype:%s\n",
           dtype==PTHREAD_CREATE_JOINABLE?"PTHREAD_CREATE_JOINABLE"
                                            :(dtype==PTHREAD_CREATE_DETACHED?
                                                   "PTHREAD_CREATE_DETACHED":"unknow"));
    pthread_attr_destroy(&t_attr);
    return (void*)0;
}

获取线程返回值实现代码如下:

void *thread_func_test1(void *arg)
{
    static int _num=999;
    pthread_exit((void*)(&_num));//trans thread return static val _num
}

void *thread_func_test2(void *arg)
{
    static int _num2=666;
    return (void*)(&_num2);//trans thread return static val _num
}

//thread exit test
    pthread_t t1,t2;
    result = pthread_create(&t1,NULL,thread_func_test1,NULL);
    if(result){printf("create thread thread_func_test1 fail\n");}
    result = pthread_create(&t2,NULL,thread_func_test2,NULL);
    if(result){printf("create thread thread_func_test1 fail\n");}

    int *pRet1,*pRet2;

    if(t1){
        pthread_join(t1,(void**)&pRet1);//get thread return value
        printf("thread thread_func_test1 return val:%d\n",*pRet1);
    }
    if(t1){
        pthread_join(t2,(void**)&pRet2);//get thread return value
        printf("thread thread_func_test2 return val:%d\n",*pRet2);
    }

取线程优先级代码如下:

    //Thread Scheduling Policy
    printf("SCHED_OTHER Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_OTHER),sched_get_priority_max(SCHED_OTHER));
    printf("SCHED_FIFO Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_FIFO),sched_get_priority_max(SCHED_FIFO));
    printf("SCHED_RR Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_RR),sched_get_priority_max(SCHED_RR));

完整实现代码:

#include <QCoreApplication>
#include <unistd.h>
//#define _GNU_SOURCE
#include <pthread.h>

//线程属性:
//分离状态: Detached State
//调度策略与参数: Scheduling Policy and Parameters
//作用域: Scope
//堆栈大小: Stack Size
//堆栈地址: Stack Address
//优先级: Priority
//结构体: pthread_attr_t
//定义头: pthreadtypes.h

int count = 1;//进程主线程全局变量count

//自定义结构体
typedef struct MyStruct
{
    //结构构造函数,构造时不传入参数,取默认值
    MyStruct(const int _age=NULL,const char* _name=NULL) {
        age= _age ? _age : 888;
        name= _name ? _name : "入侵破解比打工强多了";
    }
    int age;
    const char *name;
};

typedef struct
{
    int id;
    char *work;
}MyJob;

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *thread_func(void *arg)
{
    printf("thread_func:%s\n","这是在线程中执行输入的内容");
    return (void*)0;
}

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *thread_func_with_param(void *arg)
{
    char *str = (char*)arg;//指针强制转换
    printf("thread_func_with_param:调用线程输入的参数->%s\n",str);
    return (void*)0;
}

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *thread_func_with_cust_struct(void *arg)
{
    MyStruct *pMyStruct = (MyStruct*)arg;//强制传入参数类型转换
    printf("thread_func_with_cust_struct:调用线程传入的结构MyStruct->{age:%d,name:%s}\n",
           pMyStruct->age,pMyStruct->name);
    return (void *)0;
}

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *pthread_func_use_shared_data(void *arg)
{
    count *=20;
    printf("pthread_func_use_shared_data:%s:%d\n","共享数据count被线程pthread_func_use_shared_data修改后的值",count);
    return (void *)0;
}

//自定义线程函数,支持返回空指针,支持NULL参数的线程函数
void *thread_func_detach(void *arg)
{
    printf("thread_func_detach:%s\n","这是一个与主线程分离,独立运行的线程,会自动清理内存");
    pthread_attr_t tmpAttr;

    int s= pthread_getattr_np(pthread_self(),&tmpAttr);
    if(s!=0){
        printf("%s\n","pthread_getattr_np fail");
    }
    int nState=-1;
    s=pthread_attr_getdetachstate(&tmpAttr,&nState);
    if(s!=0){
        printf("%s\n","pthread_attr_getdetachstate fail");
    }
    printf("pthread_attr_getdetachstate:%s\n",nState==PTHREAD_CREATE_DETACHED ? "PTHREAD_CREATE_DETACHED" : (nState==PTHREAD_CREATE_JOINABLE?"":"UNKNOW"));
    pthread_attr_destroy(&tmpAttr);
    return (void*)0;
}

void *thread_func_attr_test(void *arg)
{
    printf("thread_func_attr_test\n");
    int dtype=-1;
    pthread_attr_t t_attr;
    int n = pthread_getattr_np(pthread_self(),&t_attr);
    if(n){printf("%s\n","pthread_getattr_np faile");}
    n= pthread_attr_getdetachstate(&t_attr,&dtype);
    if(n){printf("%s\n","pthread_attr_getdetachstate faile");}
    printf("dtype:%s\n",
           dtype==PTHREAD_CREATE_JOINABLE?"PTHREAD_CREATE_JOINABLE"
                                            :(dtype==PTHREAD_CREATE_DETACHED?
                                                   "PTHREAD_CREATE_DETACHED":"unknow"));
    size_t _stack_size;
    n=pthread_attr_getstacksize(&t_attr,&_stack_size);
    if(n){printf("%s\n","pthread_attr_getstacksize faile");}
    printf("stack_size:%d\n",_stack_size);
    pthread_detach(pthread_self());//detached thread from main thread

    n=pthread_getattr_np(pthread_self(),&t_attr);
    if(n){printf("%s\n","pthread_getattr_np faile");}
    n= pthread_attr_getdetachstate(&t_attr,&dtype);
    if(n){printf("%s\n","pthread_attr_getdetachstate faile");}
    printf("dtype:%s\n",
           dtype==PTHREAD_CREATE_JOINABLE?"PTHREAD_CREATE_JOINABLE"
                                            :(dtype==PTHREAD_CREATE_DETACHED?
                                                   "PTHREAD_CREATE_DETACHED":"unknow"));
    pthread_attr_destroy(&t_attr);
    return (void*)0;
}


void *thread_func_test1(void *arg)
{
    static int _num=999;
    pthread_exit((void*)(&_num));//trans thread return static val _num
}

void *thread_func_test2(void *arg)
{
    static int _num2=666;
    return (void*)(&_num2);//trans thread return static val _num
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    pthread_t tid;//线程ID
    //在进程中创建线程
    int result = pthread_create(&tid,//线程ID指针
                                NULL,//线程属性
                                thread_func,//线程函数
                                NULL//线程函数参数
                                );
    //线程创建成功返回0,错误返回非0
    if(result)
    {
        printf("main:%s\n","指向thread_func函数的线程创建失败");
    }else{
        printf("main:%s\n","thread_func线程创建成功");
        sleep(1);//主线程休眠1秒
        printf("main:%s\n","主线程输出的内容");
    }

    //创建线程并传入参数
    result = pthread_create(&tid,//线程ID
                            NULL,//线程参数
                            thread_func_with_param,//线程函数
                            (void *)"主线程传入的参数");//参数类型要强制转换为void*
    if(result){
        printf("main:%s\n","指向thread_func_with_param函数的线程创建失败");
    }else{
        printf("main:%s\n","指向执行函数thread_func_with_param的线程创建成功!");
        //阻塞主线程,直到子线程执行完成并返回
        printf("main:%s\n","主线main阻塞中,子线程thread_func_with_param执行中..");
        pthread_join(tid,NULL);
        printf("main:%s\n","子线程执行完成,返回主线程main");

    }


    //构造时使用默认值,不传入参数时不用加()
    MyStruct mystruct;
    //构造时直接赋值
    //MyStruct mystruct(999,"remotedev");
    //重新赋值结构成员
    //mystruct.age = 999 ;
    //mystruct.name = "remotedev";
    //创建线程并传入自定义结构体
    result = pthread_create(&tid,
                            NULL,
                            thread_func_with_cust_struct,
                            (void*)&mystruct);//转换指针要使用结构地址,不能直接使用结构
    if(result){
        printf("main:%s\n","指向thread_func_with_cust_struct函数的线程创建失败");
    }else{
        printf("main%s\n","指向thread_func_with_cust_struct函数的线程创建成功!");
        //阻塞主线程,直到子线程执行完成并返回
        printf("main:%s\n","主线main阻塞中,子线程thread_func_with_cust_struct执行中..");
        pthread_join(tid,NULL);
        printf("main:%s\n","子线程执行完成,返回主线程main");
    }

    //线程共享进程的数据
    printf("main:%s:%d\n","共享数据count默认值",count);
    result = pthread_create(&tid,//线程ID
                            NULL,//线程属性
                            pthread_func_use_shared_data,//线程函数
                            NULL);//线程函数参数
    if(result){
        printf("main:%s\n","指向pthread_func_use_shared_data函数的线程创建失败");
    }else{
        printf("main:%s\n","指向pthread_func_use_shared_data函数的线程创建成功!");
        printf("main:%s\n","主线main阻塞中,子线程pthread_func_use_shared_data执行中..");
        pthread_join(tid,NULL);
        printf("main:%s\n","子线程执行完成,返回主线程main");
        count-=5;
        printf("main:%s:%d\n","主线程main修改后共享数据count的值",count);
    }

    //创建线程并使用线程属性结构
    pthread_attr_t mThreadAttr;//线程属性结构
    //struct sched_param mThreadParam;//调度参数结构 暂时没使用
    size_t mStackSize;//堆栈大小
    //初始化线程属性
    int initRet = pthread_attr_init(&mThreadAttr);//因为参数是指针,所以传入地址
    //线程属性初始化返回0为成功,非0失败
    if(initRet)
    {
        printf("%s\n","线程属性初始化失败");
    }else{
        //设置线程分离状态,成功返回0,其它失败
        int x = pthread_attr_setdetachstate(&mThreadAttr,PTHREAD_CREATE_DETACHED);
        if(x)
        {
            printf("%s\n","设置线程属性为分离线程失败");
        }else{
            printf("%s\n","设置线程属性PTHREAD_CREATE_DETACHED程成功");
            //创建分离线程
            result = pthread_create(&tid,//线程id
                                    &mThreadAttr,//线程属性
                                    thread_func_detach,//线程函数
                                    NULL);//线程函数参数
            if(result){
                printf("%s\n","创建指向函数thread_func_detach的分离线程失败");
            }else{
                printf("%s\n","创建指向函数thread_func_detach的分离线程成功!");
                //printf("%s\n","休眠1秒,等待分离线程执行完成...");
                //sleep(1);
                printf("main:%s\n","子线程执行完成,返回主线程main");
                printf("main:%s\n","退出主线程,终止进程,直到子线程执行完成");
            }
        }

    }

    //create thread default is joinable
    result=pthread_create(&tid,
                            NULL,
                            thread_func_attr_test,
                            NULL);
    if(result){
        printf("thread create fail\n");
    }else{
        printf("thread create successful\n");
    }


    //释放内存
    pthread_attr_destroy(&mThreadAttr);

    //Thread Scheduling Policy
    printf("SCHED_OTHER Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_OTHER),sched_get_priority_max(SCHED_OTHER));
    printf("SCHED_FIFO Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_FIFO),sched_get_priority_max(SCHED_FIFO));
    printf("SCHED_RR Policy:min:%d-max:%d\n",sched_get_priority_min(SCHED_RR),sched_get_priority_max(SCHED_RR));


    //thread exit test
    pthread_t t1,t2;
    result = pthread_create(&t1,NULL,thread_func_test1,NULL);
    if(result){printf("create thread thread_func_test1 fail\n");}
    result = pthread_create(&t2,NULL,thread_func_test2,NULL);
    if(result){printf("create thread thread_func_test1 fail\n");}

    int *pRet1,*pRet2;

    if(t1){
        pthread_join(t1,(void**)&pRet1);//get thread return value
        printf("thread thread_func_test1 return val:%d\n",*pRet1);
    }
    if(t1){
        pthread_join(t2,(void**)&pRet2);//get thread return value
        printf("thread thread_func_test2 return val:%d\n",*pRet2);
    }

    pthread_exit(NULL);
    return a.exec();
}