我要评论1. 线程号
进程号在系统中唯一，但线程号只在其所属进程环境中有效。
（1）pthread_self函数
#include<pthread.h>
pthread_t pthread_self(void);
/*
功能：
获取线程号
返回值：
调用此函数线程的id
*/pthread_self示例：
#include<stdio.h>
#include<pthread.h>
int main(int argc, const char* argv[]) {
pthread_t tid = 0;
tid = pthread_self();
printf("当前线程id：%lu.\n", tid);
return 0;
}编译时需要加上-pthread链接到pthread库
运行结果：
（2）pthread_equal函数
int pthraed_equal(pthread_t t1, pthread_t t2);
/*
功能：
判断线程号t1、t2是否相等。
返回值：
相等：非0
不等：0
*/pthread_equal示例：
#include<stdio.h>
#include<pthread.h>
int main(int argc, const char* argv[]) {
pthread_t tid = 0;
tid = pthread_self();
if (pthread_equal(tid, pthread_self())) {
printf("线程id相等.\n");
} else {
printf("线程id不等.\n");
}
return 0;
}运行结果：
2. 线程的创建
pthread_create函数
#include<pthread.h>
int pthread_create(pthread_t* thread, const pthread_attr_t* attr,
void* (*start_coutine)(void*), void* arg);
/*
功能：
创建一个线程。
参数：
thread：线程id地址，为传出参数；
attr：线程属性结构体，通常设置为null；
start_routine：线程函数入口地址
arg：传给线程函数的参数；
返回值：
成功：0
失败：非0，未设置errno，不可使用perror。
*/pthread_create示例：
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
void* threadfunc(void* arg) { // 线程调度函数
int var = (int)(long)(arg);
printf("被创建线程id:%lu,传过来的参数：%d\n", pthread_self(), var);
return null;
}
int main(int argc, const char* argv[]) {
pthread_t tid;
int ret = -1;
// 初始化tid。因为不是所有系统中的pthread_t都是unsigned int, 因此最好使用memset初始化。
memset(&tid, 0, sizeof(tid));
// 创建线程
ret = pthread_create(&tid, null, threadfunc, (void*)0x3);
if (0 != ret) {
printf("线程创建失败！\n");
return 1;
}
printf("按下任意键继续...\n");
getchar();
printf("主线程id:%lu\n", pthread_self());
return 0;
}运行结果：
3. 线程属性
typedef struct {
int etachstate; // 线程的分离状态
int schedpolicy; // 线程的调度策略
struct sched_param schedparam; // 线程的调度参数
int inheritsched; // 线程的继承性
int scope; // 线程的作用域
size_t guardsize; // 线程栈末尾的警戒缓冲区大小
int stackaddr_set; // 线程栈的设置
void* stackaddr; // 线程栈的位置
size_t stacksize; // 线程栈的大小
} pthread_attr_t;
/*
功能：
线程属性结构体；
主要成员：
etachstate：线程的分离状态
guardsize：线程栈末尾的警戒缓冲区大小
stackaddr：线程栈的位置
stacksize：线程栈的大小
注意：
线程属性值不能直接设置，需使用相关函数进行操作。
如pthread_create之前用pthread_attr_init初始化，
之后用pthread_attr_destory释放资源。
*/（1）线程属性的初始化和销毁
#include<pthread.h>
int pthread_attr_init(pthread_attr_t* attr);
/*
功能：
初始化线程属性attr。
参数：
attr：待初始化的线程属性结构体。
返回值：
成功：0
失败：错误码
*/
int pthread_attr_destory(pthread_attr_t* attr);/*
功能：
销毁线程属性attr。
参数：
attr：线程属性结构体。
返回值：
成功：0
失败：非0错误码
*/（2）线程分离状态属性设置
- 线程分离状态：无需其他线程阻塞等待线程结束以回收已结束线程的资源，而是让内核回收已结束线程的资源。
- 线程非分离状态：某个线程（如主线程）阻塞等待子线程结束以回收其资源。
#include<pthread.h>
int pthread_attr_setdetachstate(pthread_attr_t* attr, int detachstate);
/*
功能：
设置线程属性为分离。
参数：
attr：已初始化的线程属性结构体；
detachstate：是否分离：
pthread_create_detached：分离
pthread_create_joinable：非分离
返回值：
成功：0
失败：非0
*/
int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* detachstate);
/*
功能：
获取线程是否分离状态
参数：
attr：线程属性结构体。
detachstate：是否分离：
pthread_create_detached：分离
pthread_create_joinable：非分离
返回值：
成功：0
失败：非0错误码
*/线程设置分离属性示例
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
void* func(void* arg) {
printf("子线程开始...\n");
sleep(2);
printf("子线程结束...\n");
pthread_exit(null);
}
int main(int argc, const char* argv[]) {
int ret = -1;
pthread_t tid = -1;
pthread_attr_t attr;
// 初始化线程属性
ret = pthread_attr_init(&attr);
if (0 != ret) {
printf("线程属性初始化失败。\n");
return 1;
}
// 设置线程属性为分离状态
ret = pthread_attr_setdetachstate(&attr, pthread_create_detached);
if (0 != ret) {
printf("线程分离属性设置失败。\n");
return 1;
}
// 创建线程
ret = pthread_create(&tid, &attr, func, null);
if (0 != ret) {
printf("线程创建失败.\n");
return 1;
}
sleep(3);
// join看看是否为分离状态
ret = pthread_join(tid, null);
if (0 != ret) {
printf("线程为分离状态，无需join.\n");
} else {
printf("线程为非分离状态，已被join.\n");
}
// 销毁线程属性
ret = pthread_attr_destroy(&attr);
if (0 != ret) {
printf("线程属性销毁失败。\n");
return 1;
}
return 0;
}运行结果：
（3）线程栈大小获取和设置
#include<pthread.h>
int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize);
/*
功能：
设置线程栈大小。
参数：
attr：线程属性结构体；
stacksize：线程栈大小；
返回值：
成功：0；
失败：错误码
*/
int pthread_attr_getstacksize(const pthread_attr_t* attr, size_t* stacksize);
/*
功能：
获取线程栈大小。
参数：
attr：线程属性结构体指针；
stacksize：返回的线程栈大小；
返回值：
成功：0；
失败：非0错误码
*/4. 线程的回收
（1）pthread_join函数
主线程回收线程资源，会阻塞。
#include<pthread.h>
int pthread_join(pthread_t thread, void** retval);
/*
功能：
类似于wait()函数。等待线程thread结束，回收线程资源；若线程已结束，则会立即返回。
参数：
thread：等待回收的线程号；
retval：存储进程退出状态的指针的地址；
返回值：
成功：0
失败：非0错误码
*/pthread_join示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>
void* func() {
printf("子线程开始执行...\n");
sleep(3);
printf("子线程结束执行...\n");
return (void*)0x3;
}
int main(int argc, const char* argv[]) {
pthread_t tid;
int ret = -1;
void* retp = null;
memset(&tid, 0, sizeof(tid));
// 创建线程
ret = pthread_create(&tid, null, func, null);
if (0 != ret) {
printf("线程创建失败.\n");
return 1;
}
printf("主线程执行...\n");
// 等待线程结束 pthread_join会阻塞
ret = pthread_join(tid, &retp);
if (0 != ret) {
printf("线程join失败.\n");
return 1;
}
printf("retp: %p\n", retp);
printf("主线程退出...\n");
return 0;
}运行结果：
（2）pthread_detach函数
内核回收线程资源，不会阻塞。
#include<pthread.h>
int pthread_detach(pthread_t thread);
/*
功能：
使线程thread与当前进程分离，之后线程结束后的资源回收由内核完成，因此不会阻塞。
参数：
thread：线程号；
返回值：
成功：0
失败：非0
*/pthread_detach示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
void* func(void* arg) {
printf("子线程开始...\n");
for (int i = 0; i < 3;++i) {
sleep(1);
printf("子线程工作%ds\n", i);
}
printf("子线程结束...\n");
return null;
}
int main(int argc, const char* argv[]) {
int ret = -1;
pthread_t tid = -1;
// 创建线程
ret = pthread_create(&tid, null, func, null);
if (0 != ret) {
printf("线程创建失败.\n");
return 1;
}
// 设置线程分离
ret = pthread_detach(tid);
if (0 != ret) {
printf("线程分离失败.\n");
return 1;
}
printf("主线程：按回车键退出..\n");
getchar();
return 0;
}运行结果：
线程设置为detach状态，主线程不必阻塞等待回收子线程资源，而是由内核完成。
5. 线程的退出
若在线程中用exit函数退出，则导致整个进程退出，而非退出这一个线程。
如下三者可在不结束整个进程的情况下结束线程：
a）线程从执行函数中返回；
b）线程调用pthread_exit退出线程；
c）线程被同一进程中的其它线程取消。
pthread_exit函数
#include<pthread.h>
void pthread_exit(void* retval);
/*
功能：
退出调用线程。
参数：
retval：存储线程退出状态的指针。
*/6. 线程的取消
pthread_cancel函数
#include<pthread.h>
int pthread_cancel(pthread_t thread);
/*
功能：
杀死线程thread;
参数：
thread：目标线程id;
返回值：
成功：0
失败：非0错误码。
*/pthread_cancel示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
void* func(void* arg) {
printf("子线程开始...\n");
for (int i = 0; i < 5;++i) {
sleep(1);
printf("子线程工作%ds\n", i);
}
printf("子线程结束...\n");
pthread_exit(null);
}
int main(int argc, const char* argv[]) {
int ret = -1;
pthread_t tid = -1;
// 创建线程
ret = pthread_create(&tid, null, func, null);
if (0 != ret) {
printf("线程创建失败.\n");
return 1;
}
// 设置线程分离
ret = pthread_detach(tid);
if (0 != ret) {
printf("线程分离失败.\n");
return 1;
}
sleep(3);
pthread_cancel(tid); // 杀死线程
printf("主线程：按回车键退出..\n");
getchar();
return 0;
}运行结果：
7. 线程使用注意事项
（1）主线程退出，而其余线程不退出，主线程应调用pthread_exit；
（2）避免僵尸线程方式：
- a）pthread_join；
- b）pthread_detach；
- c）pthread_create前设置线程分离属性；
（3）malloc和mmap申请的内存可被其他线程释放；
（4）避免在多线程中fork，除非马上使用exec；
（5）避免多线程中使用信号机制。
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论