Linus多线程编程（1）

线程的概念：

线程是进程内独立调度的最小执行单元。有时称为轻量级进程（Light weight Process，LWP）。程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

如何在一个进程的地址空间中执行多个线程。有些情况需要在一个进程中同时执 行多个控制流程,这时候线程就派上了用场,例如实现一个图形界面的下载软件,一方面需要和用 户交互,等待和处理用户的鼠标键盘事件,另一方面又需要同时下载多个文件,等待和处理从多个 网络主机发来的数据,这些任务都需要一个“等待-处理”的循环,可以用多线程实现,一个线程专门 负责与用户交互,另外几个线程每个线程负责和一个网络主机通信。

由于同一进程的多个线程共享同一地址空间,因此Text Segment、Data Segment都是共享的,如果定义一个函数,在各线程中都可以调用,如果定义一 个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:

1. 文件描述符表 
2. 每种信号的处理方式(SIG_IGN、SIG_DFL或者⾃定义的信号处理函数)
3. 当前工作目录
4. 用户id和组id 

但有些资源是每个线程各有一份的: 

1. 线程id 

2. 上下文,包括各种寄存器的值、程序计数器和栈指针
3. 栈空间
4. errno变量
5. 信号屏蔽字 
6. 调度优先级

我们将要学习的线程库函数是由POSIX标准定义的,称为POSIX thread或者pthread。在Linux上线 程函数位于libpthread共享库中,因此在编译时要加上-lpthread选项。

线程控制

A.线程创建

SYNOPSIS:

#include<pthread.h>

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

返回值：成功返回0，失败返回错误号。以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中,pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其他函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。

在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。atart_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void*，这个这个指针的含义同一由调用者自己定义start_routine的返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine返回值，类似于父进程调用wait()得到子进程的退出状态。

由于pthread_create的错误码不保存在errno中，因此不能直接用perror()打印错误信息，可以先用strerror(errno)把错误码转换为错误信息在打印。

代码：//pthread.c

<span style="font-size:14px;">#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<errno.h>
pthread_t tid;
void *thread_run(void *_val)
{
	printf("%s,pid:  %d,tid is :%u\n",(char*)_val, (int)getpid(),
    //(unsigned long long)pthread_self());
	tid);
	return 	NULL;
}

//if create success, return 0
//else return errno
int main()
{
	int err = pthread_create(&tid, NULL, thread_run, NULL);
	if(err != 0)
	{
		printf("create thread is failed! info is: %s\n",strerror(errno));
		exit(err);
	}
	printf("man pthread is run, pid is: %d,tid is: %u\n",(int)getpid(),
	(unsigned long long)pthread_self());
	sleep(3);
	return 0;
}</span>

编译： gcc -o pthread pthread.c -lpthread

结果：man pthread is run, pid is: 18442,tid is: 3077609152
(null),pid:  18442,tid is :307760625
...（sleep(3)）

B.线程终止

如果需要只终止某个进程而不终止整个进程，可以有三种方法：
①从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。
②一个线程可以调用pthread_cancel终止统一进程中的另一个进程。
③线程乐意调用pthread_exit终止自己。

#include<pthread.h>

void pthread_exit(void *retval);
retval是void*类型，和线程函数返回值的用法一样，其他线程可以调用pthread_join获得这个指针。需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。

线程终止后，，其终止状态一直保留到其他线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。对一个尚未detach的线程调用pthread_join或者pthread_detach都可以吧该线程置为detach状态，也就是说，不能对同一线程调用两次pthread_join，或者如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

代码：//pthread_join

<span style="font-size:14px;">#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>

void *pthread_run1(void *arg)
{
	printf("thread_run1 return \n");
	return (void*)1;
}
void *pthread_run2(void *arg)
{
	printf("thread_run2 exit!\n");
	pthread_exit((void*)2);
}
void *pthread_run3(void *arg)
{
	while(1)
	{
		printf("thread_run is running , wait for cancel!\n");
		sleep(3);
	}
	return NULL;
}

int main()
{
	pthread_t tid;
	void *_retval;
	pthread_create(&tid, NULL, pthread_run1, NULL);
	pthread_join(tid, &_retval);
	printf("thread_run1 return ,thread id is: %u, return code is: %d\n"
	,(unsigned long)tid, (int)_retval);

	pthread_create(&tid, NULL, pthread_run2, NULL);
	pthread_join(tid, &_retval);
	printf("thread_run2 exit ,thread id is: %u, exit code is: %d\n"
	,(unsigned long)tid, (int)_retval);
	
	pthread_create(&tid, NULL, pthread_run3, NULL);
	sleep(3);
	pthread_cancel(tid);
	pthread_join(tid, &_retval);
	printf("thread_run3 return ,thread id is: %u, return code is: %d\n"
	,(unsigned long)tid, (int)_retval);
	
	return 1;
}</span>

编译： gcc -o pthread_join pthread_join.c -lpthread

运行结果：

thread_run1 return 
thread_run1 return ,thread id is: 3077827440, return code is: 1
thread_run2 exit!
thread_run2 exit ,thread id is: 3077827440, exit code is: 2
thread_run is running , wait for cancel!

//sleep(3)
thread_run3 return ,thread id is: 3077827440, return code is: -1

-------------------------------------------------------------------------------------

在Linus的pthread库中常数PTHREAD_CANCELED的值是-1.

C.线程等待

int pthread_join(pthread_t pthread, void **retval);
① 如果thread通过return返回，value_ptr所指向的单元里存放的是thread线程函数的返回值。
②如果thread被别的线程pthread_cancel异常终止掉，value_ptr所指向的单元里存放的是常PTHREAD_CANCELED.
③如果thread是自己调用pthread_exit()终止的，value_ptr所指向的单元存放的是传给pthread_exit()的参数。如果thread线程的终止状态不感兴趣，可以传NULL给value_ptr参数。

有关分离线程

在任何一个时间点上，线程是可结合的（joinable）或者是分离的（detached）。已个可结合的线程能够被其他线程收回其资源和杀死。在被其他线程回收之前，它的存储器资源是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器 资源在它终止时由系统自动释放。

默认情况下，线程被创建成可结合的。为了避免存储器泄漏，每个可结合线程都应该要么被显示地回收，即调用pthread_join；要么通过调用pthread_detach函数被分离。

如果一个可结合线程结束运行但没有被join，则它的状态类似于进程中的Zombie Process，即还有一部分资源没有被回收，所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源。

由于调用pthread_join后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此。例如，在Web服务器中当主线程为每个新来的连接请求创建已个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的连接请求），这时可以在子线程中加入代码 pthread_detach(pthread_self()) 或者父线程调用pthread_detach(thread_id)（非阻塞，可立即返回）

代码：//pthread_detach.c

<span style="font-size:14px;">#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>

void *pthread_run(void *arg)
{
	pthread_detach(pthread_self());
	printf("pthread is running!\n");
	return NULL;
}

int main()
{
	pthread_t tid;
	int ret = pthread_create(&tid, NULL, pthread_run, "thread run!");
	if(ret != 0)
	{
		printf("thread create failed! \n");
		exit(1);
	}
	int _val = 0;
	sleep(3);
	if(0 != pthread_join(tid, NULL))
	{
		printf("pthread wait failed!\n");
		_val = 1;
	}
	else
	{
		printf("pthread wait success!\n");
		_val = 0;
	}
	return _val;

}</span>

编译：

gcc -o pthread_detach pthread_detach.c -lpthread

运行结果：

pthread is running!

//sleep(3)
pthread wait failed!

------------------------------------------------------------------------

如果不加 pthread_detach(pthread_self());

wait success!

这将该子线程的状态设置为分离的（detached），如此一来，该线程运行结束后会自动释放所有资源。

因此主线程 wait failed!

-----------------------------------------------------------------------------------------------------------------

一般情况下,线程终止后,其终止状态一直保留到其它线程调用pthread_join获取它的状态为 止。 但是线程也可以被置为detach 状态,这样的线程一旦终止就立刻回收它占有的所有资源, 而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join,这样的调用将 返回EINVAL。 对一个尚未detach的线程调用pthread_join或pthread_detach都可以把该线程 置为detach状态,也 就是说,不能对同一线程调用两次pthread_join,或者如果已经对一个线程调 用 了pthread_detach就不能再调用pthread_join了。