linux 线程属性参数分析(优先级，调度策略，栈大小以及其他)

柔情只为你懂 2023-02-26 02:20 4阅读 0赞

1首先我们通过几个函数来了解pthread\_attribute吧

/********
    属性结构体：
    struct attribute
    {
    	int detachstate;
    	int schepolicy;
    	struct sched_param schedparam; //调度策略优先级
    	int inheritsched;
    	int scope;
    	size_t guardsize; //线程栈末尾的警戒区缓冲大小
    	void* stackaddr; //线程站地址
    	size_t stacksize; //栈大小
    }pthread_attr_t
    
    
    线程属性：优先级，栈大小，继承主线程与否，调度策略，系统绑定
    绑定属性：一个用户线程对应一个内核线程，非绑定是由系统分配的，不确定
    分离属性：线程以什么方式结束自己
    不确定参数直接man -a 函数名
    ********/
    #include<stdio.h>
    #include<pthread.h>
    #include<string.h>
    #include<sched.h>
    #include<unistd.h>
    #include<stdint.h>
    
    void* thread_fun(void* argc)
    {
    	printf("file=%s,fun=%s,line=%d\n",__FILE__,__FUNCTION__,__LINE__);
    }
    
    int main()
    {
    	pthread_t thd,thd2;
    	struct sched_param schedparam;
    	int policy, priority, inherit, scope, detachstate,ret;
    	size_t stacksize;
    	pthread_attr_t p_attr,p_attr1;
    	pthread_attr_init(&p_attr);//默认属性
    	pthread_attr_init(&p_attr1);
    	char tempbuf[20];
    	memset(tempbuf,0,20);
    	
    	/**********************************获取默认线程属性********************************************/
    	printf("*********************************** gain thread atribute first!*********************\n");
    	pthread_attr_getschedpolicy(&p_attr,&policy); //调度策略
    	if(policy == SCHED_RR)
    	{
    		strcpy(tempbuf,"SCHED_RR");
    	}
    	if(policy == SCHED_FIFO)
    	{
    		strcpy(tempbuf,"SCHED_FIFO");
    	}
    	if(policy == SCHED_OTHER)
    	{
    		strcpy(tempbuf,"SCHED_OTHER");
    	}
    	
    	printf("line = %d,tempbuf= %s\n",__LINE__,tempbuf);
    	
    	priority = sched_get_priority_min(policy); //优先级最小值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	priority =  sched_get_priority_max(policy); //优先级最大值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	
    	//继承主线程
    	pthread_attr_getinheritsched(&p_attr,&inherit);
    	if(inherit == PTHREAD_INHERIT_SCHED) 
    	{
    		printf("PTHREAD_INHERIT_SCHED:%d\n",inherit);
    	}
    	
    	if(inherit == PTHREAD_EXPLICIT_SCHED) //不继承
    	{
    		printf("PTHREAD_EXPLICIT_SCHED:%d\n",inherit);
    	}
    	
    	//绑定属性
    	pthread_attr_getscope(&p_attr,&scope);
    	if(scope == PTHREAD_SCOPE_SYSTEM) //绑定
    	{
    		printf("PTHREAD_SCOPE_SYSTEM:%d\n",scope);
    	}
    	
    	if(scope = PTHREAD_SCOPE_PROCESS)//不绑定
    	{
    		printf("PTHREAD_SCOPE_PTHREAD:%d\n",scope);	
    	}
    	
    	 //分离属性
    	pthread_attr_getdetachstate(&p_attr,&detachstate);
    	if(detachstate == PTHREAD_CREATE_DETACHED) //分离
    	{
    		printf("PTHREAD_CREATE_DETACHED:%d\n",detachstate);	
    	}
    	
    	if(detachstate == PTHREAD_CREATE_JOINABLE) //不分离
    	{
    		printf("PTHREAD_CREATE_JOINABLE:%d\n",detachstate);
    	}
    	
    	//获取栈大小
    	pthread_attr_getstacksize(&p_attr,&stacksize);
    	printf("line = %d,stacksize=%ld\n",__LINE__,stacksize);
    	
    	//优先级
    	pthread_attr_getschedparam(&p_attr,&schedparam);
    	printf("schedparam.sched_priority = %d\n",schedparam.sched_priority );
    	
    	ret = pthread_create(&thd,&p_attr,thread_fun,NULL);
    	if(ret < 0)
    	{
    		printf("file=%s,fun=%s,line=%d return error\n",__FILE__,__FUNCTION__,__LINE__);
    	}
    	
    	/*******************************设置线程属性***********************************************/
    	printf("*********************************** set thread atribute second!*********************\n");
    	//设置线程属性：
    	policy = SCHED_FIFO;
    	pthread_attr_setschedpolicy(&p_attr1,policy);
    	
    	//获取FIFO优先级范围
    	priority = sched_get_priority_min(policy); //优先级最小值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	priority =  sched_get_priority_max(policy); //优先级最大值
    	
    	//继承主线程
    	inherit = PTHREAD_INHERIT_SCHED;
    	pthread_attr_setinheritsched(&p_attr1,inherit);
    	
    	//绑定属性
    	scope = PTHREAD_SCOPE_SYSTEM;
    	pthread_attr_setscope(&p_attr1,scope);
    	
    	//分离属性
    	detachstate = PTHREAD_CREATE_DETACHED;
    	pthread_attr_setdetachstate(&p_attr1,detachstate);
    	
    	//优先级
    	schedparam.sched_priority = 28;
    	pthread_attr_setschedparam(&p_attr1,&schedparam);
    	
    	ret = pthread_create(&thd2,&p_attr1,thread_fun,NULL);
    	if(ret < 0)
    	{
    		printf("file=%s,fun=%s,line=%d return error\n",__FILE__,__FUNCTION__,__LINE__);
    	}
    	
    	/********************************获取设置之后线程属性**********************************************/
    	printf("*********************************** gain thread atribute second(change)!*********************\n");
    	pthread_attr_getschedpolicy(&p_attr1,&policy); //调度策略
    	if(policy == SCHED_RR)
    	{
    		strcpy(tempbuf,"SCHED_RR");
    	}
    	if(policy == SCHED_FIFO)
    	{
    		strcpy(tempbuf,"SCHED_FIFO");
    	}
    	if(policy == SCHED_OTHER)
    	{
    		strcpy(tempbuf,"SCHED_OTHER");
    	}
    	
    	printf("line = %d,tempbuf= %s\n",__LINE__,tempbuf);
    	
    	priority = sched_get_priority_min(policy); //优先级最小值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	priority =  sched_get_priority_max(policy); //优先级最大值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	
    	pthread_attr_getinheritsched(&p_attr1,&inherit);
    	if(inherit == PTHREAD_INHERIT_SCHED) //继承主线程
    	{
    		printf("PTHREAD_INHERIT_SCHED:%d\n",inherit);
    	}
    	
    	if(inherit == PTHREAD_EXPLICIT_SCHED) //不继承
    	{
    		printf("PTHREAD_EXPLICIT_SCHED:%d\n",inherit);
    	}
    	
    	pthread_attr_getscope(&p_attr1,&scope);//绑定属性
    	if(scope == PTHREAD_SCOPE_SYSTEM) //绑定
    	{
    		printf("PTHREAD_SCOPE_SYSTEM:%d\n",scope);
    	}
    	
    	if(scope = PTHREAD_SCOPE_PROCESS)//不绑定
    	{
    		printf("PTHREAD_SCOPE_PTHREAD:%d\n",scope);	
    	}
    	
    	pthread_attr_getdetachstate(&p_attr1,&detachstate); //分离属性
    	if(detachstate == PTHREAD_CREATE_DETACHED) //分离
    	{
    		printf("PTHREAD_CREATE_DETACHED:%d\n",detachstate);	
    	}
    	
    	if(detachstate == PTHREAD_CREATE_JOINABLE) //不分离
    	{
    		printf("PTHREAD_CREATE_JOINABLE:%d\n",detachstate);
    	}
    	
    	//获取栈大小
    	pthread_attr_getstacksize(&p_attr1,&stacksize);
    	printf("line = %d,stacksize=%ld\n",__LINE__,stacksize);
    	
    	//优先级
    	pthread_attr_getschedparam(&p_attr1,&schedparam);
    	printf("schedparam.sched_priority = %d\n",schedparam.sched_priority );
    	pthread_attr_destroy(&p_attr);
    	pthread_attr_destroy(&p_attr1);
    	pthread_join(thd,NULL);
    	pthread_join(thd2,NULL);
    	
    	return 0;
    	
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70][]

然后我们实现以下自己封装一个自己设置优先级，调度策略的线程吧

#include<stdio.h>
    #include<pthread.h>
    #include<string.h>
    #include<sched.h>
    
    //#define STACK_SIZE (81920)
    
    int STACK_SIZE = 81920;
    
    typedef void* (*thread_fun)(void*);
    
    //优先级定义
    typedef enum sched
    {
    	SCHEID_FIFO = 0,
    	SCHEID_RR,
    	SCHEID_OTHER //分时调度
    }SCHED_PRIOTY;
    
    创建我的线程
    int ros_pthread_create(pthread_t* pid,int schem_method,int privaty,int stacksize,thread_fun threadfun,void* argc)
    {
    	pthread_attr_t attr;
    	struct sched_param schedparam;
    	int priority;
    	int ret = 0;
    	
    	memset(&attr,0,sizeof(pthread_attr_t));
    	
    	//pthread_attr_init(&attr);
    	
    	//设置线程属性：FIFO RR OTHER
    	ret = pthread_attr_setschedpolicy(&attr,schem_method);
    	
    	//获取FIFO优先级范围
    	priority = sched_get_priority_min(schem_method); //优先级最小值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	priority =  sched_get_priority_max(schem_method); //优先级最大值
    	printf("line = %d,priority= %d\n",__LINE__,priority);
    	
    	//优先级
    	schedparam.sched_priority = privaty;
    	ret = pthread_attr_setschedparam(&attr,&schedparam);
    	
    	//栈大小
    	ret = pthread_attr_setstacksize(&attr,stacksize);
    	
    	if (ret < 0)
    	{
    		printf(" fun = %s line = %d return error\n",__FUNCTION__,__LINE__);
    		return -1;
    	}
    	
    	//创建线程
    	ret = pthread_create(pid,&attr,threadfun,argc);
    	if(ret < 0)
    	{
    		printf(" fun = %s line = %d return error\n",__FUNCTION__,__LINE__);
    		return -1;		
    	}
    	
    	printf(" fun = %s create success\n",__FUNCTION__);
    }
    
    void* my_fun1(void* a)
    {
    	while(1)
    	{
    		printf(" fun1 = %s line = %d return\n",__FUNCTION__,__LINE__);
    	}
    }
    
    void* my_fun2(void* a)
    {
    	while(1)
    	{
    		printf(" fun2 = %s line = %d return\n",__FUNCTION__,__LINE__);
    	}
    }
    
    
    int main()
    {
    	pthread_t pid1,pid2;
    	int ret = ros_pthread_create(&pid1,(int)SCHEID_FIFO,1,STACK_SIZE,my_fun1,NULL);
    	if(ret < 0)
    	{
    		printf(" fun = %s line = %d return error\n",__FUNCTION__,__LINE__);
    		return -1;
    	}
    	
    	 ret = ros_pthread_create(&pid2,(int)SCHEID_FIFO,99,STACK_SIZE,my_fun2,NULL); //数字越小，优先级越高
    	if(ret < 0)
    	{
    		printf(" fun = %s line = %d return error\n",__FUNCTION__,__LINE__);
    		return -1;
    	}
    	
    	pthread_join(pid1,NULL);
    	pthread_join(pid1,NULL);
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70]: /images/20230209/6977fafdf83d476b9ae597804a8271d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70 1]: /images/20230209/6b00634a5eca4449901344d620f37a2d.png