pthread_detach函数

函数原型：int pthread_detach(pthread_t tid);

功能：

pthread_join()函数的替代函数，可回收创建时detachstate属性设置为PTHREAD_CREATE_JOINABLE的线程的存储空间。

该函数不会阻塞父线程。pthread_join()函数用于只是应用程序在线程tid终止时回收其存储空间。如果tid尚未终止，pthread_detach

()不会终止该线程。当然pthread_detach(pthread_self())也是可以得

头文件：#include
pthread非linux系统的默认库， 需手动链接-线程库 -lpthread

参数：

tid：线程标识符

返回值：

pthread_detach() 在调用成功完成之后返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况，pthread_detach()

        将失败并返回相应的值。

EINVAL：tid是分离线程

ESRCH：tid不是当前进程中有效的为分离线程

代码：

#include 
#include 
#include 
#include 
#include 
using std::cout;
using std::cin;
using std::cerr;
using std::endl;
using std::string;
struct info
{
	string name;
	unsigned s_time;//sleep时间
	pthread_t *tid;//测试使用
};
void *start_routine(void *arg)
{	
	//pthread_detach(pthread_self());
	/*测试2：pthread_detach(tid)：
	此处我通过测试线程可以调用pthred_detach使其兄弟线程分离,说明子线程的资源
	来源于进程而非父线程，从而证实所有线程的资源来源于进程
	info *t_arg = (info *) arg;
	if(t_arg->tid != nullptr)
	{
		int ret = pthread_detach(*t_arg->tid);
		if(ret == ESRCH)
		{
			cerr << "pthread_detach():ESRCH 不是当前进程中有效的未分离线程" << endl;
		}
	}
	*/
	for(unsigned i = 0; i != 5U; ++i)
	{
		cout << t_arg->name << endl;
		sleep(t_arg->s_time);
	}
	return (void *)t_arg;
}
constexpr unsigned THREAD_N = 2;//线程的数量
int main()
{
	pthread_t tid[THREAD_N];
	//pthread_attr_t *attr1 = nullptr, *attr2 = nullptr;
	int ret[THREAD_N];
	info args[THREAD_N] = {"Win", 1U, nullptr, "Unix", 2U, nullptr};
   	for(unsigned i = 0U; i != THREAD_N; ++i)
   	{
		/*
		   pthread_attr_t attr;
		   ret[i] = pthread_create(&tid[i], &attr, &start_routine, &args[i]);
		   attr需由pthread_attr_init()进行初始化，此处产生了EAGAIN错误
		 */
		if(i == 1U)
		{
			args[i].tid = &tid[i-1]; 
		}
		else
		{
			args[i].tid = nullptr;
		}
		ret[i] = pthread_create(&tid[i], nullptr, &start_routine, &args[i]);
		if(ret[i] != 0)
		{
			if(ret[i] == EAGAIN)
			{
				cerr << args[i].name << " : 超出系统限制" << endl;
			}	
			else if(ret[i] == EINVAL)
			{
				cerr << args[i].name << " : pthread_attr_t设置无效" << endl;
			}
			else 
			{
				cerr << args[i].name << ": unkown error" << endl;
			}	
			exit(-1);
		}
	}
	sleep(2);
	for(unsigned i = 0; i != THREAD_N; ++i)
	{
		ret[i] = pthread_detach(tid[i]);
		if(ret[i] != 0)
		{
			if(ret[i] == ESRCH)
			{
				cerr << args[i].name << " pthread_detach():ESRCH tid[i]不是当前进程中有效的未分离线程" << endl;
			}
			else if(ret[i] == EINVAL)
			{
				cerr << args[i].name << " pthread_detach():EINVAL tid[i]是分离线程" << endl;
			}
			else
			{
				cerr << args[i].name << " pthread_detach():unknow error" << endl;
			}
			exit(-1);
		}
	}
	cout << "pthread_detach不会阻塞父线程，当子线程结束时资源会被自动收回" << endl;
	/*
	测试1：显然tid[0]已经是分离线程
	ret[0] = pthread_detach(tid[0]);
	if(ret[0] == EINVAL)
	{
		cerr << "pthread_detach():tid是分离线程" << endl;
	}
	*/
	sleep(15);//保证子线程可以运行
	return 0;
}

收获：

加深了对线程概念的理解，线程共用进程的资源，所以线程之间的通信要比进程之间的通信简单的多