Linux 多线程编程
Linux多线程编程
1、线程
1）什么是线程
LWP：light weight process 轻量级的进程，本质仍是进程（Linux环境下）
进程：独立地址空间，拥有PCB
线程：有独立的PCB，但没有独立的地址空间（共享）
区别：在于是否共享地址空间。 独居（进程）；合租（线程）
Linux下：
- 线程：最小的执行单位
- 进程：最小分配资源单位，可看成是只有一个线程的进程
2）Linux内核线程实现原理
- 轻量级进程(light weight process)，也有PCB，创建线程使用的底层函数和进程一样， 都是clone。
- 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的。
- 进程可以蜕变成线程。
- 线程可看做寄存器和栈的集合。
- 在linux下，线程最是小的执行单位： 进程是最小的分配资源单位。
查看LWP号： ps -Lf 进程id
三级映射：进程PCB—>页目录（可看成数组，首地址位于PCB中）—>页表—>物理页面—>内存单元
进程之间：不同页目录，不同页表，不同物理页面内存单元
线程之间：相同页目录，相同页表，相同物理页面内存单元
实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数 clone
因此：Linux内核不区分进程和线程。只在用户层面进行区分，所以线程所有操作函数pthread *是库函数，而非系统调用
进程和线程的区别：
地址空间：
线程共享本进程的地址空间，而进程之间是独立的地址空间。
线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局数据，只能借助mmap
资源：
线程共享本进程的资源如内存、 I/O 、cpu 等，不利于资源的管理和保护，而进程之间的资源是独立的，
能很好的进行资源管理和保护。
健壮性：
多进程要比多线程健壮，一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。
执行过程：
每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口，执行开销大。
但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，执行开销小。
可并发性：
两者均可并发执行。
切换时：
进程切换时，消耗的资源大，效率低。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程。
其他：
线程是处理器调度的基本单位，但是进程不是
3）线程共享资源
- 文件描述符表。
- 每种信号的处理方式t
- 当前工作目录。
- 用户ID和组ID。
- 内存地址空间(.text/ .data/ .bss/heap/共享库)
4）线程非共享资源
- 线程id
- 处理器现场和栈指针（内核栈）
- 独立的栈空间（用户空间栈）
- errno 变量
- 信号屏蔽字
- 调度优先级
5）线程优缺点
优点：
- 提高程序并发性
- 充分利用多核处理器
- 开销小
- 数据通信、共享数据方便
缺点：
- 库函数，不稳定
- 调试、编写困难、gdb不支持
- 对信号支持不好
优点相对突出，缺点均不是硬伤。Linux下由于实现方式导致进程、线程差别不大
6）线程控制原语
线程控制原语和进程控制原语对比（POSIX API）
| 线程 | 进程 |
|---|---|
pthread_create() |
fork() |
pthread_self() |
getpid() |
pthread_exit() |
exit() |
| pthread_join()`` | wait/waitpid() |
pthread_cancel() |
kill() |
pthread_detach() |
①pthread_self 函数
作用：获取线程ID。
pthread_t pthread_self(void); 返回值：成功：0； 失败：无！
线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现
线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)
注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。
检查出错返回：(线程中)
fprintf(stderr, "xxx error: %s\n",strerror());
②pthread_create 函数
作用：创建一个新线程。
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：线程主函数执行期间所使用的参数。
//创建线程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.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;
tid = pthread_self();
int ret = pthread_create(&tid, NULL, tfn, NULL);
if(ret != 0){
perror("pthread_create error");
}
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
sleep(1);
return 0;
}
//循环创建子线程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.h>
#include<pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
void *tfn(void *arg)
{
int i = (int)arg; //强转
sleep(i);
printf("--I am %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);
return 0;
}
③pthread_exit 函数
作用：将单个线程退出
void pthread_exit(void *retval);
参数：retval表示线程退出状态，通常传NULL
多线程中，尽量不使用exit函数，会导致进程内所有线程退出。取而代之的是pthread_exit，将单个线程退出
任何线程里exit导致进程退出，其它线程未工作结束，主控线程退出时不能return或exit
另外注意：pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。
- return ：返回到调用者那里去
- pthread_exit()：将调用该函数的线程退出
- exit：将进程退出
④pthread_join 函数
作用：阻塞等待线程退出，获取线程退出状态
int pthread_join(pthread_t thread, void **retval);
返回值： 成功：0； 失败：错误号
注意：
- thread：线程ID （*不是指针*）；
- retval：存储线程结束状态。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.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;
}
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");
}
ret = pthread_join(tid, (void **)&retval);
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);
return 0;
}
⑤pthread_cancel 函数
作用：杀死(取消)线程其作用
int pthread_cancel(pthread_t thread);
返回值： 成功：0；失败：错误号
线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.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);
}
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
sleep(5);
ret = pthread_cancel(tid); //终止线程
if(ret != 0){
fprintf(stderr, "pthread_cancel error:%s\n", strerror(ret));
exit(1);
}
while (1);
pthread_exit((void *)0);
}
终止线程方式：
- 从线程主函数
return。这种方法对主控线程不适用，从main函数return相当于调用exit。 - 一个线程可以调用
pthread_cancel终止同一进程中的另一个线程。 - 线程可以调用
pthread_exit终止自己。
⑥pthread_detach 函数
作用：实现线程分离
int pthread_detach(pthread_t thread);
成功：0；失败：错误号
线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。
进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。
也可使用 pthread_create函数参2(线程属性)来设置线程分离。
一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。
不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.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){
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);
}
7）线程属性
①线程属性初始化
注意:应先初始化线程属性，再pthread_ create 创建线程。
初始化线程属性
int pthread_ attr init(pthread_attr_t *attr); 成功：0；失败：错误号。
销毁线程属性所占用的资源。
int pthread_attr_destroy(pthread_attr_t *attr); 成功：0；失败：错误号。
②线程的分离状态
线程的分离状态决一个线程以什么样的方式来终止自己。
非分离状态:线程的默认属性是非分离状态.这种情况下，原有的线程等待创建的线程结束。只有当pthread, join()函数返回时，创建的线程才算终止，才能是释放自己占用的系统资源。
分离状态，分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。
线程分离状态的函数:
设置线程属性，分离or非分离。
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
获取程属性，分离or非分离。
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
参数：attr：已初始化的线程属性
detachstate：PTHREAD_CREATE_DETACHED （分离线程）
PTHREAD_CREATE_JOINABLE （非分离线程）
设置分离属性步骤：
pthread_attr_t attr; //创建一个线程属性结构体变量
pthread_ attr init(&attr); //初始化线程属性
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); //设置线程属性为 分离态
pthread_create(&tid, &attr, tfn, NULL); //借助修改后的 设置线程属性 创建为分离态的新线程
pthread_attr_destroy(&attr); //销毁化线程属性
实例：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<error.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;
pthread_attr_t attr;
int ret = pthread_attr_init(&attr); //线程属性初始化
if(ret != 0){
fprintf(stderr, "att_init error:%s\n", strerror(ret));
exit(1);
}
ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); //设置线程属性为 分离属性
if(ret != 0){
fprintf(stderr, "att_setdetachstate error:%s\n", strerror(ret));
exit(1);
}
ret = pthread_create(&tid, &attr, tfn, NULL);
if(ret != 0){
perror("pthread_create error");
exit(1);
}
ret = pthread_attr_destroy(&attr);
if(ret != 0){
fprintf(stderr, "att_destroy error:%s\n", strerror(ret));
exit(1);
}
ret = pthread_join(tid, NULL); //获取线程属性/分离or不分离 == pthread_attr_getdetachstate
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);
}
8）线程使用注意事项
- 主线程退出其他线程不退出，主线程应调用
pthread_exit - 避免僵尸线程
pthread_joinpthread_detachpthread_create指定分离属性- 被
join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值；
malloc和mmap申请的内存可以被其他线程释放- 应避免在多线程模型中调用
fork，除非马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit - 信号的复杂语义很难和多线程共存，应避免在多线程中引入信号机制
浙公网安备 33010602011771号