Linux下多线程的创建和属性设置C语言

最新推荐文章于 2023-03-16 18:06:11 发布

江南必胜客

最新推荐文章于 2023-03-16 18:06:11 发布

阅读量574

点赞数 3

文章标签： LInux多线程创建线程创建 Linux线程属性设置

本文链接：https://blog.csdn.net/hq764466762/article/details/95466182

版权

最近在复习Linux下多线程的创建，所以希望记录一下多线程的创建方面的知识，查看了网上对于Linux下多线程创建的教程，很多都是有文字而无demo，看起来也不是很那个，所以我在这里总结一下我对多线程创建的认识，若有不对的地方请多指教，一起探讨学习。本文适合有一定基础的人阅读，若对线程和进场的概念还处于迷茫阶段的的话，请先了解一下。

本人绝对尊重所有原创作者，如有侵权，请联系删除

什么是多线程呢？

即就是一个程序中有多个线程在同时执行

进程与线程的关系
写程序的时候就是一个程序就是一个进程，而你需要在这个程序里面处理多个任务，分配多个资源出去处理，而这多个任务可以看作多个线程，进程是表示资源分配的基本单位，又是调度运行的基本单位，线程是操作系统可识别的最小执行和调度单位，也就是说必须有进程的存在，才有线程，线程和进程都可被操作系统识别和调度。

首先我先搞一个最简单的demo，也是最直接的线程创建。话不多说，直接上代码

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

void *thread_fun1(void *param)
{
	int ret = 0;
	printf("I conme in thread_fun1\n");
	while(1)
	{
		ret++;
		printf("hello!\n");
		sleep(1);
		if(ret >= 3)
			break;
	}
}
void *thread_fun2(void *param)
{
	int ret = 0;
	char *tmp = (char *)param;
	printf("I conme in thread_fun2\n");
	while(1)
	{
		ret++;
		printf("%s\n",tmp);
		sleep(1);
		if(ret >= 3)
			break;
	}
}

int main()
{
    pthread_t   Thread_1;
	 pthread_t  Thread_2;
	 char *thread2_param = "world";
	if (0 != pthread_create(&Thread_1,NULL, thread_fun1, NULL)) 
	{
		perror("thread_fun pthread_create failed!\n");
		return -1;
	}
	if (0 != pthread_create(&Thread_2,NULL, thread_fun2,thread2_param )) 
	{
		perror("thread_fun pthread_create failed!\n");
		return -1;
	}
	printf("wailt pthread over\n");
	if(0 == pthread_join(Thread_1,NULL))//等待子线程的释放(结束)
	{
		printf("Thread_1 Release Success\n");
	}
	if(0 == pthread_join(Thread_2,NULL))//等待子线程的释放(结束)
	{
		printf("Thread_2 Release Success\n");
	}
    /*这里仅用来标识子线程是否已经释放*/
	while(1)
	{
		printf("end pro\n");
		sleep(1);
	}
    return 0;
}

上面就是一个简单的线程创建，我喜欢先举例再来探讨

int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,(void*)(*start_rtn)(void*),void *arg);这个函数就是创建线程的，若线程创建成功，则返回0。若线程创建失败，则返回出错编号。

第一个参数为指向线程标识符的指针。

第二个参数用来设置线程属性。

第三个参数是线程处理函数的首地址。

最后一个参数是用来传递线程处理函数的。

int pthread_join(pthread_t thread, void **retval);当调用 pthread_join() 时，当前线程会处于阻塞状态，直到被调用的线程结束后，当前线程才会重新开始执行。当 pthread_join() 函数返回后，被调用线程才算真正意义上的结束。如果一个线程是非分离的（默认情况下创建的线程都是非分离）并且没有对该线程使用 pthread_join() 的话，该线程结束后并不会释放其内存空间，这会导致该线程变成了“僵尸线程”

pthread_t thread: 被连接线程的线程号
void **retval : 指向一个指向被连接线程的返回码的指针的指针

返回值：0是成功，非0失败

下面来看看程序运行效果：

从打印可以看出来，毫不意外，线程创建成功并且顺利执行了处理函数，并且释放掉线程。有人或者会想为什么先打印wailt Thread over呢？因为线程是分配出去进依赖主进程的资源而独立运行的，创建一个线程也是需要时间的。好了，这个创建一个子线程的demo就说到这里了。

下面我们来谈谈线程创建的属性
先上代码

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

void *thread_fun1(void *param)
{
	int ret = 0;
	printf("I conme in thread_fun1\n");
	while(1)
	{
		ret++;
		printf("hello!\n");
		sleep(1);
		if(ret >= 3)
			break;
	}
}
void *thread_fun2(void *param)
{
	int ret = 0;
	char *tmp = (char *)param;
	printf("I conme in thread_fun2\n");
	while(1)
	{
		ret++;
		printf("%s\n",tmp);
		sleep(1);
		if(ret >= 3)
			break;
	}
}

int main()
{
    pthread_t   Thread_1;
	 pthread_t  Thread_2;
	 char *thread2_param = "world";
	 pthread_attr_t 		thread_attr;
    pthread_attr_init(&thread_attr);
	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);//线程设置为分离状态
	
	if (0 != pthread_create(&Thread_1,&thread_attr, thread_fun1, NULL)) 
	{
		perror("thread_fun pthread_create failed!\n");
        pthread_attr_destroy (&thread_attr);
		return -1;
	}
    pthread_attr_destroy (&thread_attr);
	if (0 != pthread_create(&Thread_2,NULL, thread_fun2,thread2_param )) 
	{
		perror("thread_fun pthread_create failed!\n");
		return -1;
	}
    printf("wailt pthread over\n");
	if(0 == pthread_join(Thread_1,NULL))//等待子线程的释放(结束)
	{
		printf("Thread_1 Release Success\n");
	}
	if(0 == pthread_join(Thread_2,NULL))//等待子线程的释放(结束)
	{
		printf("Thread_2 Release Success\n");
	}
 /*这里仅用来标识子线程是否已经释放*/
	while(1)
	{
		printf("end pro\n");
		sleep(1);
	}
    return 0;
}

程序运行结果

这个线程创建中，我设置了线程属性，设置为分离状态，其它属性用的比较少我也就不举例了，在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。也就是当线程结束的时候，占用的资源就会自动释放。这样是不是就很方便了，不用老是等待子线程的结束。下面看看线程属性设置，可以多练练玩玩，这里我就不一一设置了。

const pthread_attr_t *attr；

线程属性结构如下：
typedef struct
{
int                           detachstate;     线程的分离状态
int                          schedpolicy;   线程调度策略
struct sched_param      schedparam;   线程的调度参数
int                          inheritsched;    线程的继承性
int                          scope;          线程的作用域
size_t                      guardsize; 线程栈末尾的警戒缓冲区大小
int                          stackaddr_set;
void *                     stackaddr;      线程栈的位置
size_t                      stacksize;       线程栈的大小
}pthread_attr_t;

1.    分离状态:
            线程的分离状态决定一个线程以什么样的方式来终止自己。

            我们已经在前面已经知道，在默认情况下线程是非分离状态的，这种情况
            下，原有的线程等待创建的线程结束。只有当pthread_join() 函数返回
            时，创建的线程才算终止，才能释放自己占用的系统资源。

            分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，
            马上释放系统资源。

            通俗的说也就是：我们知道一般我们要等待(pthread_join)一个线程的结束，
            主要是想知道它的结束状态，否则等待一般是没有什么意义的！但是if有一
            些线程的终止态我们压根就不想知道，那么就可以使用“分离”属性，那么我
            们就无须等待管理，只要线程自己结束了，自己释放src就可以咯！这样更
            方便！

            #include <pthread.h>
            int pthread_attr_getdetachstate(const pthread_attr_t * attr, int * detachstate);
            int pthread_attr_setdetachstate(pthread_attr_t * attr, int detachstate);
            参数：attr:线程属性变量
                    detachstate:分离状态属性
            若成功返回0，若失败返回-1。

            设置的时候可以有两种选择：
            <1>.detachstate参数为：PTHREAD_CREATE_DETACHED     分离状态启动
            <2>.detachstate参数为：PTHREAD_CREATE_JOINABLE    正常启动线程

2    线程的继承性：

            函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设
            置和得到线程的继承性!

            #include <pthread.h>
            int pthread_attr_getinheritsched(const pthread_attr_t *attr,int *inheritsched);
            int pthread_attr_setinheritsched(pthread_attr_t *attr,int inheritsched);
            参数：
            attr                线程属性变量
            inheritsched     线程的继承性
            若成功返回0，若失败返回-1。

            请注意：
            继承性决定调度的参数是从创建的进程中继承还是使用在
            schedpolicy和schedparam属性中显式设置的调度信息。

            线程没有默认的继承值设置，所以如果关心线程的调度策略和参数，
            只能手动设置！

            可设置参数：
            PTHREAD_INHERIT_SCHED：新的线程继承创建线程的策略和参数！
            PTHREAD_EXPLICIT_SCHED：新的线程继承策略和参数来自于
                                                schedpolicy和schedparam属性中显式
                                                设置的调度信息！

>>>>>:    下面补充线程调度策略和调度参数：
            <1>.调度策略：

                    函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用
                    来设置和得到线程的调度策略。

                    int pthread_attr_getschedpolicy(const pthread_attr_t *, int * policy)
                    int pthread_attr_setschedpolicy(pthread_attr_*, int policy)
                    参数：
                            attr            线程属性变量
                            policy        调度策略
                    若成功返回0，若失败返回-1。

                    所谓调度策略也就是我们之前在OS中所学过的那些调度算法：
                    SCHED_FIFO    ：先进先出
                    SCHED_RR       ：轮转法
                    SCHED_OTHER    ：其他方法

                    SCHED_OTHER是不支持优先级使用的,而SCHED_FIFO和SCHED_RR
                    支持优先级的使用,他们分别为1和99,数值越大优先级越高.

                    注意：
                            > 此处的SCHED_FIFO是允许被高优先级抢占的！
                            > 也就是有高优先级的必须先运行
                            > SCHED_RR是设置一个时间片
                            > 当有SCHED_FIFO或SCHED_RR策赂的线程在一个条件变量
                            上等持或等持加锁同一个互斥量时，它们将以优先级顺序被唤
                            醒。即，如果一个低优先级的SCHED_FIFO线程和一个高优先
                            织的SCHED_FIFO线程都在等待锁相同的互斥且，则当互斥量
                            被解锁时，高优先级线程将总是被首先解除阻塞。

            <2>.调度参数：

                    函数pthread_attr_getschedparam 和pthread_attr_setschedparam分别
                    用来设置和得到线程的调度参数。



                    int pthread_attr_getschedparam(const pthread_attr_t *,struct
                    sched_param *);
                    int pthread_attr_setschedparam(pthread_attr_t *,const struct
                    sched_param *);
                    参数：
                            attr            线程变量属性
                            param        sched_parm 结构体
                    若成功返回0，若失败返回-1。

                    /usr/include /bits/sched.h
                    struct sched_param
                    {
                           int sched_priority;    //!> 参数的本质就是优先级
                    };
                    注意：大的权值对应高的优先级!
                    系统支持的最大和最小的优先级值可以用函数：
                    sched_get_priority_max和sched_get_priority_min得到！

                    #include <pthread.h>
                    int sched_get_priority_max( int policy );
                    int sched_get_priority_min( int policy );
                    参数：max_：    系统支持的优先级的最小值
                            min_ ：    系统支持的优先级的最大值

                    使用：max_ = sched_get_priority_max( policy );
                            min_ = sched_get_priority_min( policy );
                            注意参数是policy调用策略，也就是说对于不同的策略的值是不
                            一样的！

                    附录：来自
                    http://www.yuanma.org/data/2006/0823/article_1392.htm
                    policy = SCHED_OTHER
                    max_priority = 0
                    min_priority = 0

                    Show SCHED_FIFO of priority
                    max_priority = 99
                    min_priority = 1

                    Show SCHED_RR of priority
                    max_priority = 99
                    min_priority = 1

                    Show priority of current thread
                    priority = 0

3.    线程的作用域：

            函数pthread_attr_setscope和pthread_attr_getscope分别
            用来设置和得到线程的作用域。
            #include <pthread.h>
            int    pthread_attr_getscope( const pthread_attr_t * attr, int * scope );
            int pthread_attr_setscope( pthread_attr_t*, int scope );
            参数：
                    attr               线程属性变量
                    scope         线程的作用域
            若成功返回0，若失败返回-1。

            作用域控制线程是否在进程内或在系统级上竞争资源，可能的值是
            PTHREAD_SCOPE_PROCESS（进程内竞争资源）
            PTHREAD_SCOPE_SYSTEM   （系统级竞争资源）。

4.    线程堆栈的大小

            函数pthread_attr_setstackaddr和pthread_attr_getstackaddr分别用来设置和得
            到线程堆栈的位置。

            int pthread_attr_getstacksize(const pthread_attr_t *,size_t * stacksize);
            int pthread_attr_setstacksize(pthread_attr_t *attr ,size_t *stacksize);
            参数：attr                线程属性变量
                    stacksize        堆栈大小
            若成功返回0，若失败返回-1。

5.    线程堆栈的地址

            #include <pthread.h>
            int pthread_attr_getstackaddr(const pthread_attr_t *attr,void **stackaddf);
            int pthread_attr_setstackaddr(pthread_attr_t *attr,void *stackaddr);
            参数：attr               线程属性变量
                    stackaddr     堆栈地址
            若成功返回0，若失败返回-1。

            注意：pthread_attr_getstackaddr已经过期，现在使用的是：pthread_attr_getstack

6.    警戒缓冲区

            函数pthread_attr_getguardsize和pthread_attr_setguardsize分别用来设置和得
            到线程栈末尾的警戒缓冲区大小。

            #include <pthread.h>
            int pthread_attr_getguardsize(const pthread_attr_t *restrict attr,size_t *restrict
            guardsize);
            int pthread_attr_setguardsize(pthread_attr_t *attr ,size_t *guardsize);
            若成功返回0，若失败返回-1。

            值得注意：
                        线程属性guardsize控制着线程栈末尾之后以避免栈溢出的扩展内存
                        大小。这个属性默认设置为PAGESIZE个字节。可以把guardsize线
                        程属性设为0，从而不允许属性的这种特征行为发生：在这种情况
                        下不会提供警戒缓存区。同样地，如果对线程属性stackaddr作了
                        修改，系统就会认为我们会自己管理栈，并使警戒栈缓冲区机制无
                        效，等同于把guardsize线程属性设为0。

参考博文：https://www.cnblogs.com/jacklikedogs/p/4030048.html

江南必胜客

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Linux下多线程的创建和属性设置C语言

最近算法的同事问我关于Linux下多线程的创建，所以希望记录一下多线程的创建方面的知识，查看了网上对于Linux下多线程创建的教程，很多都是有文字而无demo，看起来也不是很那个，所以我在这里总结一下我对多线程创建的认识，若有不对的地方请多指教，一起探讨学习。本文适合有一定基础的人阅读，若对线程和进场的概念还处于迷茫阶段的的话，请先了解一下。本人绝对尊重所有原创作者，如有侵权，请联系删除什...
复制链接

扫一扫