多线程(上)
Posted WoLannnnn
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多线程(上)相关的知识，希望对你有一定的参考价值。
文章目录
Linux线程概念
什么是线程
在一个程序里的一条执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”
一切进程至少都有一个执行线程
线程在进程内部运行，本质是在进程地址空间内运行
在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化
透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流
Linux不提供线程的创建
线程的优点
- 创建一个新线程的代价要比创建一个新进程小得多
- 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
- 线程占用的资源要比进程少很多
- 能充分利用多处理器的可并行数量
- 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
- 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
- I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作
线程的缺点
性能损失
一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。健壮性降低
编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。缺乏访问控制
进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。编程难度提高
编写与调试一个多线程程序比单线程程序困难得多
线程异常
- 单个线程如果出现除零、野指针等问题导致线程崩溃，进程也会随着崩溃
- 线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该
进程内的所有线程也就随即退出
线程用途
- 合理的使用多线程，能提高CPU密集型程序的执行效率
- 合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）
Linux进程VS线程
进程和线程
进程是资源分配的基本单位
线程是调度的基本单位
线程共享进程数据，但也拥有自己的一部分数据:
- 线程ID
- 一组寄存器(重点)，有自己的硬件上下文
- 栈(重点)，有自己的栈空间，共有的栈空间会变得混乱
- errno
- 信号屏蔽字
- 调度优先级
进程的多个线程共享 同一地址空间,因此Text Segment、Data Segment都是共享的,如果定义一个函数,在各线程中
都可以调用,如果定义一个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:
- 文件描述符表
- 每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)
- 当前工作目录
- 用户id和组id
进程和线程的关系如下图:
关于进程线程的问题
如何看待之前学习的单进程？具有一个线程执行流的进程
Linux线程控制
POSIX线程库
- 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
- 要使用这些函数库，要通过引入头文件<pthread.h>
- 链接这些线程函数库时要使用编译器命令的“-lpthread”选项
创建线程
功能：创建一个新的线程
原型
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)
(void*), void *arg);
参数
thread:返回线程ID
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数指针，线程启动后要执行的函数
arg:传给线程启动函数start_routine的参数
返回值：成功返回0；失败返回错误码
错误检查:
- 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
- pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回
- pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值判定，因为读取返回值要比读取线程内的errno变量的开销更小
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
void* pthread_handler(void *arg)
//线程1
while (1)
printf("I am thread 1\\n");
sleep(1);
int main()
pthread_t tid;
int ret;
//创建线程
ret = pthread_create(&tid, NULL, pthread_handler, NULL);
if (ret < 0)
perror("pthread_creat");
exit(1);
//主线程
while (1)
printf("I am main thread\\n");
sleep(1);
return 0;
生成可执行文件时，要加-lpthread选项，也可以写成 -pthread，但不推荐。要让编译器知道我们使用的是哪个具体的库。
为什么不加-I和-L选项呢
因为该头文件和库的路径在系统默认路径下
结果：
进程ID和线程ID
- 在Linux中，目前的线程实现是Native POSIX Thread Libaray,简称NPTL。在这种实现下，线程又被称为轻量 级进程(Light Weighted Process),每一个用户态的线程，在内核中都对应一个调度实体，也拥有自己的进程描述符(task_struct结构体)。
- 没有线程之前，一个进程对应内核里的一个进程描述符，对应一个进程ID。但是引入线程概念之后，情况发生了变化，一个用户进程下管辖N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符一下子就变成了1：N关系，POSIX标准又要求进程内的所有线程调用getpid函数时返回相同的进程ID，如何解决上述问题呢？
- Linux内核引入了线程组的概念
图中的tgid，含义是Thread Group ID,该值对应的是用户层面的进程ID ，gettid可以获取当前线程的id
现在介绍的线程ID，不同于pthread_t类型的线程ID，和进程ID一样，线程ID是pid_t类型的变量，而且是用来唯一标识线程的一个整型变量。如何查看一个线程的ID呢？
[root@localhost linux]# ps -eLf |head -1 && ps -eLf |grep a.out |grep -v grep UID PID PPID LWP C NLWP STIME TTY TIME CMD root 28543 22937 28543 0 2 15:32 pts/0 00:00:00 ./a.out root 28543 22937 28544 0 2 15:32 pts/0 00:00:00 ./a.outps命令中的-L选项，会显示如下信息：
LWP:线程ID，既gettid()系统调用的返回值。
NLWP:线程组内线程的个数
可以看出上面a.out进程是多线程的，进程ID为28543，进程内有2个线程，线程ID(LWP的ID)分别为28543，28544
Linux提供了gettid系统调用来返回其线程ID，可是glibc并没有将该系统调用封装起来，在开放接口来共程序员使用。如果确实需要获得线程ID，可以采用如下方法： #include <sys/syscall.h> pid_t tid; tid = syscall(SYS_gettid);
从上面可以看出，a.out进程的ID为28543，下面有一个线程的ID也是28543，这不是巧合。线程组内的第一个线程，在用户态被称为主线程(main thread),在内核中被称为group leader，内核在创建第一个线程时，会将线程组的ID的值设置成第一个线程的线程ID，group_leader指针则指向自身，即主线程的进程描述符。所以线程组内存在一个线程ID等于进程ID，而该线程即为线程组的主线程
/* 线程组ID等于线程ID，group_leader指向自身 */ p->tgid = p->pid; p->group_leader = p; INIT_LIST_HEAD(&p->thread_group);至于线程组其他线程的ID则由内核负责分配，其线程组ID总是和主线程的线程组ID一致，无论是主线程直接创建线程，还是创建出来的线程再次创建线程，都是这样。
if ( clone_flags & CLONE_THREAD ) p->tgid = current->tgid; if ( clone_flags & CLONE_THREAD ) P->group_lead = current->group_leader; list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系
线程ID及进程地址空间布局
pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是
一回事。前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要 一个数值来唯一表示该线程。
pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于 NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：
pthread_t pthread_self(void);pthread_t到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。 也就是对应下图中每一个结构体pthread的内存的起始地址。
因为Linux不会创建线程，所以线程是用户创建和管理的， 内核中由底层的LWP(执行流)执行
pthread库既然创建了线程，就要负责管理线程：描述(结构体TCB)，组织。
TCB中有一个pid数据标识线程的id，指向轻量级进程(LWP)，LWP帮我们完成线程的执行功能。
进程id，内核线程id，pthread线程id打印：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>
void* handler(void* arg)
while (1)
printf("i am thread... 进程id:%d, 线程id:%ld, pthread_id:%ld\\n", getpid(), syscall(SYS_gettid), pthread_self());
sleep(1);
int main()
pthread_t tid;
int ret = 0;
ret = pthread_create(&tid, NULL, handler, NULL);
if (ret < 0)
perror("pthread_create error!");
return 1;
//主线程
while (1)
printf("i am main thread... 进程id:%d, 线程id:%ld, pthread_id:%ld\\n", getpid(), syscall(SYS_gettid), pthread_self());
sleep(1);
return 0;
线程等待 为什么需要线程等待？
- 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内，会造成类似僵尸进程的结果。
- 创建新的线程不会复用刚才退出线程的地址空间
功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针，指针指向线程的返回值
返回值：成功返回0；失败返回错误码
调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:
- 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
- 如果thread线程被别的线程调用pthread_ cancel异常终止掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED(值为-1)。
- 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数。
- 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread1(void *arg)
printf("thread 1 returning ... \\n");
int *p = (int*)malloc(sizeof(int));
*p = 1;
return (void*)p;
void *thread2(void *arg)
printf("thread 2 exiting ...\\n");
int *p = (int*)malloc(sizeof(int));
*p = 2;
pthread_exit((void*)p);
void *thread3(void *arg)
while ( 1 )
printf("thread 3 is running ...\\n");
sleep(1);
return NULL;
int main( void)
pthread_t tid;
void *ret;
// thread 1 return
pthread_create(&tid, NULL, thread1, NULL);
pthread_join(tid, &ret);
printf("thread return, thread id %X, return code:%d\\n", tid, *(int*)ret);
free(ret);
// thread 2 exit
pthread_create(&tid, NULL, thread2, NULL);
pthread_join(tid, &ret);
printf("thread return, thread id %X, return code:%d\\n", tid, *(int*)ret);
free(ret);
// thread 3 cancel by other
pthread_create(&tid, NULL, thread3, NULL);
sleep(3);
pthread_cancel(tid);
pthread_join(tid, &ret);
if ( ret == PTHREAD_CANCELED )
printf("thread return, thread id %X, return code:PTHREAD_CANCELED\\n", tid);
else
printf("thread return, thread id %X, return code:NULL\\n", tid);
运行结果：
[root@localhost linux]# ./a.out
thread 1 returning ...
thread return, thread id 5AA79700, return code:1
thread 2 exiting ...
thread return, thread id 5AA79700, return code:2
thread 3 is running ...
thread 3 is running ...
thread 3 is running ...
thread return, thread id 5AA79700, return code:PTHREAD_CANCELED
线程终止
如果只需要终止某个线程而不终止整个进程,可以有三种方法:
- 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
- 线程可以调用pthread_ exit终止自己。如果线程直接调用exit函数，会使整个进程退出，所以exit终止的是进程
- 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。
注意：线程的退出只关心执行结果正不正确，因为当线程异常退出时，进程也退出了。
pthread_exit函数
功能：线程终止
原型
void pthread_exit(void *value_ptr);
参数
value_ptr:value_ptr不需要指向一个局部变量。一般是将结果强转为指针，在读取退出信息时再强转为int/long类型
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）
需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数
的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。
使用示例：
#include<stdio.h>
#include<pthread.h>
void* handle(void*arg)
int i = 0;
while(1)
if (5 == i)
break;
sleep(1);
printf("this is a thread: %d\\n", pthread_self());
++i;
pthread_exit((void*) 10);//设置线程的退出码为10
int main()
pthread_t tid;
pthread_create(&tid, NULL, handle, NULL);
void*ptr = NULL;
pthread_join(tid, &ptr);//主线程等待新线程
//打印退出码
printf("exit code:%d\\n", (long long)ptr);
return 0;
结果:
pthread_cancel函数
功能：取消一个执行中的线程
原型
int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码
被取消的线程会返回将宏PTHREAD_CANCELED(值为-1)返回给等待它的线程(等待接下来就讲)
不一定是只由主线程取消，也可以由其他进程取消，当然，也可以自杀(自己取消自己，这种行为很奇怪)
示例：
#include<stdio.h>
#include<pthread.h>
void* handle(void*arg)
int i = 0;
while(1)
//if (5 == i)
// break;
sleep(1);
printf("this is a thread: %d\\n", pthread_self());
++i;
//pthread_exit((void*) 10);
int main()
pthread_t tid;
pthread_create(&tid, NULL, handle, NULL);
sleep(10);
//主线程等10s再取消新线程
pthread_cancel(tid);
void*ptr = NULL;
//获取退出码
pthread_join(tid, &ptr);
printf("exit code:%d\\n", (long long)ptr);
return 0;
结果：
注意：主线程调用pthread_cancel函数， 则主线程的状态变更成为Z， 其他线程不受影响
分离线程
- 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
- 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。
int pthread_detach(pthread_t thread);
可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:
pthread_detach(pthread_self());
joinable和分离是冲突的，一个线程不能既是joinable又是分离的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_run( void * arg )
//自己分离
pthread_detach(pthread_self());
printf("%s\\n", (char*)arg);
return NULL;
int main( void )
pthread_t tid;
if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) //创建线程
printf("create thread error\\n");
return 1;
int ret = 0;
sleep(1);//很重要，要让线程先分离，再等待
if ( pthread_join(tid, NULL ) == 0 )
printf("pthread wait success\\n");
ret = 0;
else
printf("pthread wait failed\\n");
ret = 1;
return ret;
注意：如果分离的线程崩溃了，主线程还是会崩溃，也就是进程还是会跟着遭殃。
Linux线程互斥
进程线程间的互斥相关背景概念
- 临界资源：多线程执行流同时共享的资源就叫做临界资源 ，有一些资源虽然是共享的但不会被访问
- 临界区：每个线程内部，访问临界资源的代码，就叫做临界区
- 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
- 原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成
互斥量mutex
- 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
- 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
- 多个线程并发地操作共享变量，会带来一些问题
首先我们要明白，线程之间的代码和数据都是共享的，不同于进程有写时拷贝，所以一个线程修改了数
以上是关于多线程(上)的主要内容，如果未能解决你的问题，请参考以下文章