这篇文章详细介绍了POSIX线程编程中的关键函数，包括pthread_self获取线程ID，pthread_create创建线程，pthread_join等待线程退出，pthread_exit线程退出以及pthread_cancel取消线程。强调了线程间的资源共享和线程安全问题，提供了多个示例代码来说明线程的创建、同步和退出操作。
编译的时候记得后面
-l pthread毕竟第三方库实现
pthread_self函数
获取线程ID。 其作用对应进程中 getpid() 函数。
pthread_t pthread_self(void);
返回值：成功：0； 失败：无！
线程ID：pthread_t类型
本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现
线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)
注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。
pthread_create函数
创建一个新线程。 其作用，对应进程中fork() 函数。
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
返回值：成功：0； 失败：错误号
-----Linux环境下，所有线程特点，失败均直接返回错误号。
参数：
pthread_t：当前Linux中可理解为：typedef unsigned long int pthread_t;
参数1：传出参数，保存系统为我们分配好的线程ID
参数2：通常传NULL，表使用线程默认属性。若想使用具体属性可修改该参数。
参数3：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
参数4：线程主函数执行期间所使用的参数。
在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。
start_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态，稍后详细介绍pthread_join。
pthread_create成功返回后，新创建的线程的id被填写到thread参数所指向的内存单元。我们知道进程id的类型是pid_t，每个进程的id在整个系统中是唯一的，调用getpid(2)可以获得当前进程的id，是一个正整数值。线程id的类型是thread_t，它只在当前进程中保证是唯一的，在不同的系统中thread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印，调用pthread_self(3)可以获得当前线程的id。
案例一： 创建一个新线程，打印线程ID
如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，我们在main函数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新创建的线程执行，下一节我们会看到更好的办法。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *tfn(void *arg)
{
printf("thread: pid = %d, tid = %lu\n", getpid(), pthread_self());
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t tid;
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
sys_err("pthread_create error");
}
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
sleep(1);
return 0;
}案例二：循环创建多个线程
循环创建多个线程，每个线程打印是第几个被创建的线程。(类似于进程循环创建子进程)
- %lu表示输出无符号长整型整数
- 编译指令
gcc test.c -o test -l pthread(注意加后面的)- 需要注意的是，不要让进程先于子线程结束，毕竟共享一片内存空间（代码中的sleep）
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *tfn(void *arg)
{
int i = (int)arg; //void* 强转回 int
sleep(i);
printf("--- I'm %dth thread: pid = %d, tid = %lu\n", i+1, getpid(), pthread_self());
return NULL;
}
int main(int argc, char *argv[])
{
int i, ret;
pthread_t tid;
for(i = 0;i < 5; i++)
{
ret = pthread_create(&tid, NULL, tfn, (void*)i);// 强转i 传进线程 传参采用值传递
if(ret != 0){
sys_err("pthread_create error");
}
}
sleep(i);
printf("main: I'm main: pid = %d, tid = %lu\n", getpid(), pthread_self());
return 0;
}
案例二：错误写法分析
思考：将pthread_create函数参4修改为(void *)&i, 将线程主函数内改为 i=*((int *)arg) 是否可以？
从结果很容易看出i的打印出现的问题，那是因为当我们从子进程（函数内）通过i的地址取值的时候。这个i的地址是在父进程栈区。这片地址存放的值i可能已经发生了变化。毕竟父进程也一直在执行。
线程与共享
线程间共享全局变量！
【牢记】：线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局变量，只能借助mmap。
练习：设计程序，验证线程之间共享全局数据。
pthread_exit函数
将单个线程退出
void pthread_exit(void *retval);
参数：retval表示线程退出状态，通常传NULL
思考：使用exit将指定线程退出，可以吗？
结论：线程中，禁止使用exit函数，会导致进程内所有线程全部退出。（重）
在不添加sleep控制输出顺序的情况下。pthread_create在循环中，几乎瞬间创建5个线程，但只有第1个线程有机会输出（或者第2个也有，也可能没有，取决于内核调度）如果第3个线程执行了exit，将整个进程退出了，所以全部线程退出了。
所以，多线程环境中，应尽量少用，或者不使用exit函数，取而代之使用pthread_exit函数，将单个线程退出。任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit。
另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。
案例三：pthread_exit 编写多线程程序
练习：编写多线程程序，总结exit、return、pthread_exit各自退出效果。
return：返回到调用者那里去。
pthread_exit()：将调用该函数的线程退出
exit: 将进程退出。
主控线程退出时不能 return 或 exit。(重)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *func(void)
{
return NULL;
}
void func1(void)
{
pthread_exit(NULL); //将当前线程退出
return ;
}
void *tfn(void *arg)
{
int i = (int)arg; //void* 强转回 int
sleep(i);
if(i == 2){
//exit(0); //表退出进程
//return NULL; //表示返回到 函数调用者那里去
//func(); //不能退出
func1(); //可以退出 pthread_exit(NULL) 将当前线程退出
}
printf("--- I'm %dth thread: pid = %d, tid = %lu\n", i+1, getpid(), pthread_self());
return NULL;
}
int main(int argc, char *argv[])
{
int i, ret;
pthread_t tid;
for(i = 0;i < 5; i++)
{
ret = pthread_create(&tid, NULL, tfn, (void*)i);// 强转i 传进线程
if(ret != 0){
sys_err("pthread_create error");
}
}
//sleep(i);
printf("main: I'm main: pid = %d, tid = %lu\n", getpid(), pthread_self());
//return 0;
pthread_exit((void*)0); //将当前线程退出 可不加sleep()，将return替换掉
}
pthread_join函数
阻塞等待线程退出，获取线程退出状态 其作用，对应进程中 waitpid() 函数。
补充：任意线程得到其他线程的pid都可以回收，没有父线程回收子线程的说法。而进程需要父进程回收子进程。
int pthread_join(pthread_t thread, void **retval);
成功：0；失败：错误号
参数：
thread：线程ID （【注意】：不是指针）；
retval：存储线程结束状态。
对比记忆：
进程中：main返回值、exit参数-->int；等待子进程结束 wait 函数参数-->int *
线程中：线程主函数返回值、pthread_exit-->void *；等待线程结束 pthread_join 函数参数-->void **
调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：
- 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。
- 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。
- 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。
- 如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。
案例四： pthread_join 实例
// int 简单案例
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *tfn(void *arg)
{
return (void *)74;
}
int main(int argc, char *argv[])
{
pthread_t tid;
int *retval;
//创建子线程
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
sys_err("pthread_create error");
}
//阻塞等待线程退出 获取线程退出状态
//int pthread_join(pthread_t thread, void **retval);
ret = pthread_join(tid, (void **)&retval); //对应进程中的waitpid()函数
if(ret != 0){
sys_err("pthread_join error");
}
printf("child thread exit with %d\n", (void *)retval);
pthread_exit(NULL); //主线程退出
}
//结构体案例
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
struct thrd{
int var;
char str[256];
};
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *tfn(void *arg)
{
//初始化结构体 并返回
struct thrd *tval;
tval = malloc(sizeof(tval));
tval->var = 100;
strcpy(tval->str, "hello thread");
return (void *)tval;
}
/*
void *tfn(void *arg) //错误写法
{
struct thrd tval; //局部变量地址，不可做返回值
tval.var = 100;
strcpy(tval->str, "hello thread");
return (void *)&tval;
}
*/
int main(int argc, char *argv[])
{
pthread_t tid;
struct thrd *retval;
//创建子线程
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
sys_err("pthread_create error");
}
//阻塞等待线程退出 获取线程退出状态
//int pthread_join(pthread_t thread, void **retval);
ret = pthread_join(tid, (void **)&retval); //对应进程中的waitpid()函数
if(ret != 0){
sys_err("pthread_join error");
}
printf("child thread exit with var= %d, str= %s\n", retval->var, retval->str);
pthread_exit(NULL); //主线程退出
}
pthread_cancel函数
杀死(取消)线程 其作用，对应进程中 kill() 函数。
int pthread_cancel(pthread_t thread);
成功：0；失败：错误号
【注意】：线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。
取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write..... 执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。
可粗略认为一个系统调用(进入内核)即为一个取消点。如线程中没有取消点，可以通过调用pthread_testcancel函数自行设置一个取消点。
案例五：pthread_cancel函数实例
/*
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void *tfn(void *arg)
{
while(1){
printf("thread: pid = %d, tid= %lu\n", getpid(), pthread_self());
sleep(1);
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t tid;
//创建子线程
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
fprintf(stderr, "pthread_create error:%s\n", strerror(ret));
exit(1);
}
sleep(5);
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
ret = pthread_cancel(tid); //终止子线程
if(ret != 0){
fprintf(stderr, "pthread_cancel error:%s\n", strerror(ret));
exit(1);
}
while(1);
pthread_exit((void *)0);
}
pthread_detach函数
实现线程分离 主线程（join）无法再等待回收子线程资源。
int pthread_detach(pthread_t thread);
成功：0；失败：错误号
线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。
进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。
也可使用 pthread_create函数参2(线程属性)来设置线程分离。
案例六：pthread_detach 实例
fprintf(stderr, "pthread_create error: %s\n", strerror(ret)); // 线程中 检查出错返回
实现线程分离，线程结束后，自动释放资源。无需pthread_join() 回收资源。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void *tfn(void *arg)
{
printf("thread: pid = %d, tid= %lu\n", getpid(), pthread_self());
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t tid;
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
fprintf(stderr, "pthread_create error: %s\n", strerror(ret)); //线程中 检查出错返回
exit(1);
}
ret = pthread_detach(tid); //设置线程分离 线程终止，会自动清理pcb，无需回收
if(ret != 0){
fprintf(stderr, "pthread_detach error: %s\n", strerror(ret));
exit(1);
}
sleep(1);
ret = pthread_join(tid, NULL);
printf("join ret = %d\n", ret); //回收不到了
if(ret != 0){
fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
exit(1);
}
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
pthread_exit((void *)0);
}
终止线程的三种方式
总结：终止某个线程而不终止整个进程，有三种方法：
- 从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用exit。
- 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
- 线程可以调用pthread_exit终止自己。
案例七：终止线程的三种方法。
【练习】：终止线程的三种方法。注意“取消点”的概念。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
void *tfn1(void *arg)
{
printf("thread 1 returning\n");
return (void *)111;
}
void *tfn2(void *arg)
{
printf("thread 2 exiting\n");
pthread_exit((void *)222);
}
void *tfn3(void *arg)
{
while(1){
//printf("thread3: I'm going to die in 3 seconds ...\n");
//sleep(1); //无取消点
pthread_testcancel(); //自己添加取消点
}
return (void *)666;
}
int main(int argc, char *argv[])
{
pthread_t tid;
void *tret = NULL;
pthread_create(&tid, NULL, tfn1, NULL);
pthread_join(tid, &tret);
printf("thread 1 exit code = %d\n\n", (int)tret);
pthread_create(&tid, NULL, tfn2, NULL);
pthread_join(tid, &tret);
printf("thread 2 exit code = %d\n\n", (int)tret);
pthread_create(&tid, NULL, tfn3, NULL);
sleep(3);
//被杀死的线必须有机会进入内核态 cancel类似信号 若线程没机会进入内核，那就杀不死
pthread_cancel(tid);
pthread_join(tid, &tret);
printf("thread 3 exit code = %d\n\n", (int)tret);
return 0;
}
控制原语对比
线程使用注意事项（重要）
- 主线程退出其他线程不退出，主线程应调用pthread_exit
- 避免僵尸线程
pthread_join
pthread_detach
pthread_create指定分离属性
被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;
- malloc和mmap申请的内存可以被其他线程释放（线程共享堆区）
- 应避免在多线程模型中调用fork除非，马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit
- 信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制
扫一扫
7677
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
