linux 线程创建 同步 资源回收

最新推荐文章于 2024-08-22 01:20:49 发布
最新推荐文章于 2024-08-22 01:20:49 发布
阅读量297 收藏 2
点赞数
分类专栏： C linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/poject/article/details/85778584
版权

例子1：互斥锁 + 条件变量

/*

主线程：创建两个线程，创建完了等待两个线程同步，并等待他们退出
线程1： 1）打印 XXX 2） 如果主程序进入等待状态叫醒他 3) 退出的时候自己回收资源
线程2： 1）打印 XXX 2） 如果主程序进入等待状态叫醒他 3）等待线程1 退出后

*/

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

#include<signal.h>

#define PRINT_ERROR(ret) do{ printf("ERROR: %s: %s\n",__FUNCTION__, strerror(ret)); }while(0);
#define PRINT_ERRORID(ret) do{ printf("%s: %d\n",__FUNCTION__, ret); }while(0);

int g_status=0; // 0: init 1:start wait 
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* thread_1_fun(void*);
void* thread_2_fun(void*);

int main(int argc, char** argv)
{
	printf("main: start... \n");
	pthread_t thread_1, thread_2;
	int ret;

	printf("main: creete thread 1... \n");
	ret = pthread_create(&thread_1, NULL, thread_1_fun, NULL);
	if(ret != 0) PRINT_ERROR(ret);
	printf("main: creeate thread 1 end... \n");

	printf("main: create thread 2... \n");
	ret = pthread_create(&thread_2, NULL, thread_2_fun, &thread_1); // transfer thread 1 id as paramter
	if(ret != 0) PRINT_ERROR(ret);
	printf("main: creeate thread 2 end... \n");

	//这个等待有可能被 线程1 或者 线程2 唤醒 
	// 由于线程执行的不可预测性，唤醒前有可能收到两个线程发过来的 pthread_cond_signal，但是只有一个起作用
	pthread_mutex_lock(&mutex);
	printf("main: status 0->1 wait... \n");
	g_status = 1;
	pthread_cond_wait(&cond, &mutex);
	pthread_mutex_unlock(&mutex);

#if 0 //can set status to 2 and let thread 2 to wait and wakeup it
	pthread_mutex_lock(&mutex);
	printf("main: status 1->2 wait... \n");
	g_status = 2;
	pthread_cond_wait(&cond, &mutex);
	pthread_mutex_unlock(&mutex);
#endif

	//pthread_detach(thread_1);//也可以在子程序中 pthread_detach(pthread_self());
	ret = pthread_join(thread_1, NULL); //如果这个线程已经结束，返回错误：Invalid argument /如果是一个detach线程，返回错误：No such process
	if(ret != 0) PRINT_ERROR(ret);

	ret = pthread_join(thread_2, NULL); //等待 进程2结束并回收其占用的资源，8K堆栈
	if(ret != 0) PRINT_ERROR(ret);

	printf("main: end... \n");
	exit(0);
}

void* thread_1_fun(void* arg)
{
	printf("  T1: start... \n");
	
	//同步操作，等待主程序创建完线程 并 进入 等待状态
	while(1)
	{
		pthread_mutex_lock(&mutex);
		if(g_status == 1)
		{
			pthread_mutex_unlock(&mutex);
			break;
		}
		pthread_mutex_unlock(&mutex);
	}
	
	pthread_mutex_lock(&mutex);
	if(g_status == 1)
	{
		printf("  T1: wakeup main cond signal -> ...\n");
		pthread_cond_signal(&cond);
	}
	pthread_mutex_unlock(&mutex);

	printf("  T1: end \n");

	// 与主线程分离，线程结束的时候自己释放资源
	pthread_detach(pthread_self());
	//sleep(1);
	/*
		//也可以在创建的时候指定这个属性
		pthread_attr_t attr;
		pthread_t thread;
		pthread_attr_init (&attr);pthread_attr_setdetachstat(&attr, PTHREAD_CREATE_DETACHED);
		pthread_create (&thread, &attr, &thread_function, NULL);
	*/

	pthread_exit(0);
}

void* thread_2_fun(void* arg)
{
	printf("  T2: start... \n");

	//同步操作，等待主程序创建完线程 并 进入 等待状态
	while(1)
	{
		pthread_mutex_lock(&mutex);
		if(g_status == 1) //
		{
			pthread_mutex_unlock(&mutex);
			break;
		}
		pthread_mutex_unlock(&mutex);
	}

	pthread_mutex_lock(&mutex);
	if(g_status == 1)
	{
		printf("  T2: wakeup main cond signal -> ...\n");
		pthread_cond_signal(&cond);
	}
	pthread_mutex_unlock(&mutex);

	//等待线程1结束
	pthread_join(*(pthread_t*)arg, NULL);
	
	printf("  T2: end \n");
	pthread_exit(0);
}


例子二：信号量

/*

主线程：创建两个线程，创建完了等待两个线程同步，并等待他们退出
线程1： 1）打印 XXX 2） 如果主程序进入等待状态叫醒他 3) 退出的时候自己回收资源
线程2： 1）打印 XXX 2） 如果主程序进入等待状态叫醒他 3）等待线程1 退出后

*/

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

#include<signal.h>
#include <semaphore.h>

#define PRINT_ERROR(ret) do{ printf("ERROR: %s: %s\n",__FUNCTION__, strerror(ret)); }while(0);

sem_t sem1; //子线程等待主线程同步信号
sem_t sem2; //主线程等待子线程同步信号

void* thread_1_fun(void*);
void* thread_2_fun(void*);

int main(int argc, char** argv)
{
	printf("main: start... \n");
	pthread_t thread_1, thread_2;
	int ret;

	sem_init(&sem1,0,0);
	sem_init(&sem2,0,0);

	printf("main: create thread 1... \n");
	ret = pthread_create(&thread_1, NULL, thread_1_fun, NULL);
	if(ret != 0) PRINT_ERROR(ret);
	printf("main: create thread 1 end... \n");

	printf("main: creeate thread 2... \n");
	ret = pthread_create(&thread_2, NULL, thread_2_fun, &thread_1); // transfer thread 1 id as paramter
	if(ret != 0) PRINT_ERROR(ret);
	printf("main: creeate thread 2 end... \n");

	//同步信号开始
	printf("main: send first sync signal to child \n");
	sem_post(&sem1);
	printf("main: send second sync signal to child \n");
	sem_post(&sem1);

	// 阻塞并等待被唤醒（确认子线程是否都收到信号）
	printf("main: wait sync signal from child thread... \n");
	sem_wait(&sem2);
	printf("main: receive first sync signal from thread \n");
	sem_wait(&sem2);
	printf("main: receive second sync signal from thread \n");

	//sleep(1);
	//如果不等子线程 主线程执行完了之后，子线程也会被系统回收，并结束运行
	ret = pthread_join(thread_1, NULL); //如果这个线程已经结束，返回错误：Invalid argument /如果是一个detach线程，返回错误：No such process
	if(ret != 0) PRINT_ERROR(ret);

	ret = pthread_join(thread_2, NULL); //等待 进程2结束并回收其占用的资源，8K堆栈
	if(ret != 0) PRINT_ERROR(ret);

	printf("main: end... \n");
	exit(0);
}

void* thread_1_fun(void* arg)
{
	printf("  T1: start & wait for sync... \n");
	sem_wait(&sem1);
	printf("  T1: sync OK \n");

	printf("  T1: send sync signal to main \n");
	sem_post(&sem2);

	while(1)
	{
		printf("  T1: running.. \n");
		sleep(1);
	}

	printf("  T1: end \n");

	pthread_exit(0);
}

void* thread_2_fun(void* arg)
{
	printf("  T2: start & wait for sync... \n");
	sem_wait(&sem1);
	printf("  T2: sync OK \n");

	printf("  T2: send sync signal to main \n");
	sem_post(&sem2);

	while(1)
	{
		printf("  T2: running.. \n");
		sleep(1);
	}

	printf("  T2: end \n");

	pthread_exit(0);
}

如下内容来源 https://blog.youkuaiyun.com/u013139008/article/details/78584724

创建线程时的属性设置
1. 线程的调度策略：
SCHED_OTHREAD 非实时调度策略。线程优先级为0，每个线程都不抢占其他的线程。线程会受到时间片的限制。会一直占用系统分配给他的时间片。
SCHED_RR 实时调度策略。线程优先级1-99，数值越大，优先级越高。系统分配给一个线程一个时间片，这个时间片运行过程中不会被打断。但是当时间片运行结束，下一个时间片会分给优先级更高的线程。
SCHED_FIFO 实时调度策略。线程优先级1-99，数值越大，优先级越高。时间片首先分配给优先级最高的线程。一旦时间片分配给一个线程，除非线程主动挂起和退出，该线程会一直占用CPU。线程按照不同的优先级有不同的线程队列。在一个队列中先进先出。
=>实时调度策略会抢占非实时调度策略。除非非实时的线程运行结束，否则实时的线程是不可能得到运行的。
  一个进程里面可能有多种调度策略的线程。
pthread_attr_t attr;
struct sched_param param;
param._sched_prority = 10;
pthread_attr_init(&attr);
pthread_attr_setschedpolicy(&attr, SCHED_RR/SCHED_FIFO);
pthread_attr_setschedparam(&attr, &param);
pthread_create(xxx, &attr, xxx, xxx);
pthread_attr_destroy(&attr);


2. 线程优先级的作用范围：
PTHREAD_SCOPE_SYSTEM 线程的优先级的作用范围是整个系统。即线程和系统中所有的线程竞争CPU的时间。
PTHREAD_SCOPE_PROCESS 线程的优先级的作用氛围是当前进程。即线程和该进程中其他线程竞争CPU时间。
pthread_attr_t attr;
struct sched_param param;
param._sched_prority = 10;
pthread_attr_init(&attr);
pthread_attr_setschedpolicy(&attr, SCHED_RR/SCHED_FIFO);
pthread_attr_setschedparam(&attr, &param);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM/PTHREAD_SCOPE_PROCESS);
pthread_create(xxx, &attr, xxx, xxx);
pthread_destroy(&attr);


3. 线程和其他线程是否分家：
PTHREAD_CREATE_DETACHED 新线程不能用pthread_join函数来同步，而且在退出时自行释放所占用的资源。
PTHREAD_CREATGE_JOINABLE 默认值。可以使用pthread_detach(pthread_id)改变分家状态。
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);


4. 线程栈的大小：
栈是线程的属性，在创建线程的时候，可以指定栈的大小。但是程序运行的过程中，栈的大小不能改变。即线程创建出来，大小就确定。
int stack_size;
pthread_attr_setstacksize(&attr, stack_size);
pthread_attr_getstacksize(&attr, &stack_size);
PTHREAD_STACK_MIN 栈的最小值
 

...

Linux线程同步（1）
oorik的博客
09-16 1127
如果线程 A 执行这个过程期间就失去了 CPU 时间片，线程 A 被挂起了最新的数据没能更新到物理内存。线程 B 变成运行态之后从物理内存读数据，很显然它没有拿到最新数据，只能基于旧的数据往后数，然后失去 CPU 时间片挂起。线程 A 得到 CPU时间片变成运行态，第一件事儿就是将上次没更新到内存的数据更新到内存，但是这样会导致线程 B已经更新到内存的数据被覆盖，活儿白干了，最终导致有些数据会被重复数很多次。
Linux 线程，创建，分离，回收详解
a_happy_ant的博客
11-16 384
并行和并发的区别 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果–宏观上并行，针对单核处理器） 互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。 同步(synchronous)：进程之间的关系不是相互排斥临界资源的关系，而是相互依赖的关系。进一步的说明：就是前一个进程
Linux学习——线程的创建、结束、回收、分离
weixin_73680102的博客
06-11 1002
简单介绍Linux中的线程创建、结束、回收、分离
pthread_detach(pthread_self());用法举例
热门推荐
hktkfly6的专栏
03-24 1万+
void* reboot_thread_func() {     pthread_detach(pthread_self());     usleep(3000000);/*sleep 3s*/     system("reboot");     pthread_exit((void *)NULL); } 可以自清除线程未释放的资源
linux线程资源回收
ycc541的专栏
05-09 754
在写网络服务器程序时可能需要实现多线程接收多个客户端的数据，我实现方式比较傻，死循环等待client的connect，connect之后创建thread，这样其实有一个问题，服务器程序需要长期运行，长时间线程的创建，线程资源的回收就是一个问题。     Linux系统中程序的线程资源是有限的，表现为对于一个程序其能同时运行的线程数是有限的。而默认的条件下，一个线程结束后，其对应的资源不会被释
Linux线程创建与同步
qq_41721746的博客
10-27 431
1. 线程介绍 2. 线程使用 （1）常用接口 （2）多线程代码 （3）线程并发运行 3. 线程同步 （1）信号量 （2）互斥锁 （3）条件变量 （4）读写锁 4. 线程安全
linux系统编程 线程回收
m0_59008960的博客
03-24 416
pthread_join（）函数 头文件：#include<pthread.h> 原型：int pthread_join(pthread_t thread,void **retval); retval：获得线程调用pthread_exit的信息 返回值：成功返回0;失败返回错误号 作用：阻塞等待线程并且回收线程资源（PCB） 回收单个线程： 1 #include<stdio.h> 2 #include<pthread.h> 3 #include&
Linux线程同步
shbj的博客
01-08 1976
Linux线程同步 1.互斥量 确保同一时间只有一个线程访问数据。 pthread_mutex_t mut; //两种初始化方法 mut = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_init(&mut, NULL); 1.初始化 int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexa
linux 反复创建销毁线程,Linux：回收循环创建的多个线程
weixin_33987275的博客
05-06 825
上午我说了循环创建多个线程，由于进程与线程是如此的相似，进程我们知道要回收，那么线程也自然要回收啦。我们接着看控制原语：线程与共享线程间共享全局变量！【牢记】：线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局变量，只能借助mmap。pthread_exit函数将单个线程退出void pthread_exit(void *retval);参数：retval表示线程退出...
Linux 线程：线程同步、生产者消费者模型
Han同学
04-05 1016
Linux 线程同步、生产者消费者模型
Linux线程之回收资源（十一）
qq_39721016的博客
09-11 461
Linux线程之回收资源（十一）1.线程的创建2.参考代码 1.线程的创建 int pthread_join(pthread_t thread, void **retval); 功能： 等待线程结束（此函数会阻塞），并回收线程资源，类似进程的 wait() 函数。如果线程已经结束，那么该函数会立即返回。 参数： thread：被等待的线程号。 retval：用来存储线程退出状态的指针的地址。 返回值： 成功：0 失败： 非0 2.参考代码 /*******************************
linux进程资源回收,linux线程资源回收
weixin_29974217的博客
04-29 384
from:http://blog.youkuaiyun.com/skyflying2012/article/details/24655751及相关论坛在写网络服务器程序时可能需要实现多线程接收多个客户端的数据，我实现方式比较傻，死循环等待client的connect，connect之后创建thread，这样其实有一个问题，服务器程序需要长期运行，长时间线程的创建，线程资源的回收就是一个问题。Linux系统中程...
Linux线程退出、资源回收、资源清理的方法
weixin_33814685的博客
05-23 657
首先说明线程中要回收哪些资源，理解清楚了这点之后在思考资源回收的问题。 1、子线程创建时从父线程copy出来的栈内存; 　　线程退出有多种方式，如return，pthread_exit,pthread_cancel等；线程分为可结合的（joinable）和 分离的（detached）两种，如果没有在创建线程时设置线程的属性为PTHREAD_CREATE_DETACHED，则线程默认是可结合的。...
linux：线程及其相关函数，线程的回收
最新发布
T66656的博客
08-22 1020
它用于释放线程在运行过程中申请的资源，确保程序不会出现资源泄漏，在大型项目中子线程申请的资源可能会在别的函数里使用，所以不可能该子线程结束了就清除资源，应该在其它地方使用后，统一清除这些资源才用这2个函数清除资源pthread_cleanup_push 和 pthread_cleanup_pop。线程的传参的类型为void **retval，在这里传的是**retval,这个是指针的指针，含义大多为改变指针的指向，对于函数传参来说，一个*代表传值，而**代表传一个指针的指向。本质上是一个函数的名称即可。
线程的创建与回收
ssz__的博客
01-20 1379
成功返回0，失败时返回错误码thread:线程对象attr:线程属性，NULL代表默认属性routine:线程执行的函数arg:传递给routine的参数，参数是void *，注意传递参数格式pthread_t pthread_self(void) 查看自己的TID//testThread强制返回void *最后一个参数。
Linux学习——线程的创建和回收
qq_52479948的博客
11-08 844
Linux学习笔记
linux线程回收
超哥的专栏
08-20 916
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);1. 设置线程属性 如果线程创建时，attr属性设置为NULL，那么线程采用默认的属性joinable。需要将属性设置为detachedint
linux 线程退出资源回收,有关linux线程资源回收的有关问题
weixin_35820008的博客
05-08 214
有关linux线程资源回收的问题使用linuxc编程的，开启一个线程，这个线程中申请了一些资源。如果需要这个线程马上取消并且回收申请的资源怎么办啊？前面使用了pthread_cancel()这个函数，设置了取消点，可是这个也不能立刻就取消回收资源啊啊。。。还有没有其他方法啊？------解决方案--------------------如果进程没有结束，这样回收也只是表面上的回收而已！达不到实际回...
Linux线程资源回收（转）
caotuo_csdn的博客
06-23 375
在写网络服务器程序时可能需要实现多线程接收多个客户端的数据，我实现方式比较傻，死循环等待client的connect，connect之后创建thread，这样其实有一个问题，服务器程序需要长期运行，长时间线程的创建，线程资源的回收就是一个问题。 Linux系统中程序的线程资源是有限的，表现为对于一个程序其能同时运行的线程数是有限的。而默认的条件下，一个线程结束后，其对应的资源不会被释放，于是，如果在一个程序中，反复建立线程，而线程又默认的退出，则最终线程资源耗尽，进程将不再能建立新的线程。 解决这个问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值