Linux系统编程：线程创建、回收、分离

线程创建、回收、分离

一、线程的概念

1.1线程与进程的区别

进程：分配资源（内存）的最小单位,有独立的 进程地址空间,有独立的pcb。

线程：程序执行的最小单位,没有独立的进程地址空间,有独立的pcb。每一个进程由一个或 者多个线程组成，即每个进程至少有一个主线程。

1.2线程之间的资源共享

独享：栈空间（内核栈、用户栈）
共享 ./text ./data ./rodata ./bsss heap 全局变量

1.3线程id

与进程相似，每个线程都有自己的id，获取线程id函数如下：

pthread_t pthread_self(void);

在头文件<pthread.h>中
返回值：本线程id，其类型为pthread_t

二、线程的创建

2.1创建函数

int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*start_rountn)(void *), void *arg);

pthread_t *tid：传出参数，新创建的线程 id
const pthread_attr_t *attr：线程属性。可以设置，默认为NULL。
void *(*start_rountn)(void *)：子线程回调函数。线程创建成功，该函数会被自动调用。
void *arg：回调函数的参数。没有的话，传NULL。
返回值：成功：0 ，失败：errno。

2.2创建一个线程

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

void *thread_fun(void *argc){    //回调函数，子线程执行的函数
	printf("new tread\n");
	return NULL;
}

int main(int argc,char*argv[]){
	int ret;
	pthread_t tid;
	
	ret = pthread_create(&tid,NULL,thread_fun,NULL);  //创建子线程
	if(ret ! = 0){
		printf("create failed\n");
		exit(1);
	}
	sleep(1);   //等待子线程运行完
	printf("mian thread\n");
	
	return 0;
}

输出

2.3创建多个线程

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

void *thread_fun(void *argc){
	int th = (int)argc;
	sleep(th);   //子线程依次执行
	printf("--I am thread %dth, pid=%d, tid=%lu\n",th+1,getpid(),pthread_self()); //打印进程id,线程id
	return NULL;
}

int main(int argc,char*argv[]){
	int i;
	int ret;
	pthread_t tid;

	for(i = 0; i < 5;i++){     //循环创建线程
		ret = pthread_create(&tid,NULL,thread_fun,(void*)i);
		if(ret != 0){
			printf("create failed\n");
			exit(1);
		}
	}
	
	sleep(i);  //等待所有子线程执行完
	printf("main: I am main , pid=%d,tid=%lu\n",getpid(),pthread_self());  //打印进程id,主线程id

	return 0;
}

从结果看出，进程id一样，线程id不同。

三、线程回收

3.1概述

主线程生成并执行子线程，主线程可能将于子线程之前结束，但是如果主线程需要用到子线程的处理结果，即主线程需要等待子线程执行完成之后再结束，这个时候就要用到pthread_join()方法了。

pthread_join()有两种作用：
1.用于等待其他线程结束：当调用 pthread_join() 时，当前线程会处于阻塞状态，直到被调用的线程结束后，当前线程才会重新开始执行。

2.对线程的资源进行回收：如果没有对线程使 pthread_join() 的话，该线程结束后并不会释放其内存空间，这会导致该线程变成了“僵尸线程”。分离属性线程除外。

3.2函数原型

int pthread_join(pthread_t thread, void **retval);

thread: 待回收的线程id
retval：传出参数。 回收的那个线程的退出值。
返回值：成功：0，失败：errno

3.3 主线程等待子线程

void *thread_fun(void *argc){    //回调函数，子线程执行的函数
	sleep(5);
	printf("new thread sleep 5s\n");
	return NULL;
}

int main(int argc,char*argv[]){
	int ret;
	pthread_t tid;
	
	ret = pthread_create(&tid,NULL,thread_fun,NULL);  //创建子线程
	if(ret != 0) {
		printf("create failed\n");
	}

	pthread_join(tid,NULL);   //主线程阻塞
	printf("main thread\n");
	
	return 0;
}

运行结果：

当主线程运行到pthread_join(tid,NULL)，便会阻塞在这里，等待子线程回调函数执行完，然后主线程继续下执行。

3.4接受子线程的返回值

typedef struct {
    int id;
    int age;;
    char name[64];
}stu;


void *thread_fun(void *arg)
{
 
    stu * retvar = (stu *)malloc(sizeof(exit_t));
    retvar->id=1;
    retvar-> age= 16;
    strcpy(retvar->name,"uzi");
    //子线程退出
    return (void *)retvar;

}

int main(void)
{
    pthread_t tid;
    int ret;
    stu * retval;
    
    ret = pthread_create(&tid,NULL,thrd_func,NULL);

    if(ret != 0){
        printf("create failed\n");
        exit(1);
    }
    
    pthread_join(tid,(void **)&retval);   //接受回调函数的返回值
    printf("子线程返回值为\n");
    printf("id = %d ,age = %d,name = %s\n",retval->id,retval->age,retval->name);

    return 0;
}                                              

运行结果：

3.5接受多个线程的返回值

int val = 0;

void *thread_fun(void *arg){
	
	int i;
	i = (int)arg;
	sleep(i);
	switch(i){
		case 0 :
			val = 100;
			return (void*)val;
		//	break;
		case 1 :	
			val = 200;
			return (void*)val;
		//	break;
		case 2 :
			val = 300;
			return (void*)val;
		//	break;
		case 3 :
			val = 400;
			return (void*)val;
		//	break;
		default :	
			val = 500;
			return (void*)val;
		//	break;
	}
	return NULL;

}

int main(void)
{
    pthread_t tid[5];  //保存线程id
    int ret;
	int i;
    int * retval[5];    //存储接受的返回值
  
    for(i = 0;i < 5;i++){
		ret = pthread_create(&tid[i],NULL,thread_fun,(void*)i);  //给线程传参i

		 if(ret != 0){
			printf("create failed\n");
			exit(1);
		 }
	}
	for(i = 0;i < 5 ;i++){
		pthread_join(tid[i],(void **)&retval[i]);   //接受回调函数的返回值i
		 printf("I am thread %dth,val=%d,tip=%lu\n",i+1,val,pthread_self());
	}
	 printf("I am main val=%d,tip=%lu\n",val,pthread_self());
    return 0;
}                                              

结果：

从结果可以看出，各个线程是共享全局变量的。

3.6关于返回值的总结

参考https://blog.csdn.net/liuyuchen282828/article/details/100345308

调用函数的线程将挂起等待，直到 id 为 thread 的线程终止。 thread 线程以不同的方法终止，通过 pthread_join 得到的终止状态是不同的，总结如下：

1.如果 thread 线程通过 return 返回，retval 所指向的单元里存放的是 thread 线程函数的返回值，此时进程会返回到调用者，不会结束。

2.如果 thread 线程被别的线程调用 pthread_cancel 异常终止掉， retval 所指向的单元里存放的是常数PTHREAD_CANCELED。

3.如果 thread 线程是自己调用 pthread_exit 终止的，retval 所指向的单元存放的是传给 pthread_exit 的参数。

4.如果对 thread 线程的终止状态不感兴趣，可以传 NULL 给 retval 参数。

四、线程分离

线程区别于进程，线程可以将自己与主线程分离开。可以用函数形式分离，也可以通过在创建线程时，将其属性设置为分离属性。

4.1函数形式

函数的形式很简单

int pthread_detach(pthread_t thread);	

thread: 待分离的线程id
返回值：成功：0，失败：errno

4.2函数的运用

主线程来获取子线程的返回值

void *thread_fun(void *arg){
    int n=3;
    while(n--){
        printf("thread count %d\n",n);
        sleep(1);
    }   

    return (void *)1;
}

int main(void){
    pthread_t tid;
    void *tret;
    int err;
    
    pthread_create(&tid,NULL,thread_fun,NULL);
    pthread_detach(tid);        //线程分离   
    
    while(1){
        err = pthread_join(tid,&tret);   //获取返回值
        printf("---------err= %d\n",err);
        if(err != 0)
            fprintf(stderr,"thread error: %s\n",strerror(err));              
        else
            fprintf(stderr,"thread exit code %d\n",(int)tret);

        sleep(1);
    } 

结果：

由于子线程与主线程分离，主线程不能再获取返回值，则会发生错误。