线程
线程的概念
LWP: light weight process 轻量级的进程,本质仍是进程(在 Linux 环境下)。
进程: 独立地址空间,拥有 PCB
线程: 有独立的 PCB,但没有独立的地址空间(共享)
区别: 在于是否共享地址空间。 独居(进程); 合租(线程)。
Linux 下;
线程: 最小的执行单位。
进程: 最小分配资源单位,可看成是只有一个线程的进程。
ps -Lf 进程id ——> 获取进程的线程表
Linux内核线程实现原理
- 轻量级进程(light-weight process),也有PCB,创建线程使用的底层函数和进程一样,都是 clone
- 从内核里看进程和线程是一样的,都有各自不同的 PCB,但是 PCB 中指向内存资源的三级页表是相同的.
- 进程可以蜕变成线程。
- 线程可看做寄存器和栈的集合
- 在 linux下,线程最是小的执行单位;进程是最小的分配资源单位。
三级页表:PCB ——> 页目录 ——> 页表 ——> 物理页面 ——> 内存单元
线程共享资源
- 文件描述符表(全局变量)
- 每种信号的处理方式
- 当前工作目录
- 用户 ID 和组 ID
- 内存地址空间(.text/.data/.bss/heap/共享库)
非共享资源
- 线程 id
- 处理器现场和栈指针(内核栈)
- 独立的栈空间(用户空间栈)
- errno 变量
- 信号屏蔽字 mask
- 调度优先级
线程优缺点
优点:
- 提高程序并发性
- 开销小
- 数据通信、共享数据方便
缺点:
- 库函数,不稳定
- 调试、编写困难、gdb不支持
- 对信号支持不好
优点相对突出,缺点均不是硬伤。Lnux下由于实现方法导致进程、线程差别不是很大。
线程控制原语
pthread_self 函数
获取线程ID,线程ID是在进程地址空间内部,用来标识线程身份的
pthread_t pthread_self(void);
返回值:
本线程ID
pthread_create 函数
创建线程
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
参数:
thread:新线程ID
attr:线程属性
start_routine:回调函数
arg:start_routine函数的参数
返回值:
成功:0
失败:error number
头文件:
#include <pthread.h>
示例
#include <bits/stdc++.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
using namespace std;
void sys_err(const char *str){
perror(str);
exit(1);
}
void* tfn(void* arg){
intptr_t data = reinterpret_cast<intptr_t>(arg);
int i = static_cast<int>(data);
sleep(i);
cout<<"thread "<< i+1 <<" : pid = "<<getpid()<<", tid = "<<pthread_self()<<endl;
return NULL;
}
int main(int argc,char *argv[]){
pthread_t tid;
int ret,i;
for(i=0;i<5;i++){
ret = pthread_create(&tid,NULL,tfn, reinterpret_cast<void*>(i));
if(ret != 0){
sys_err("pthread_create error");
}
}
sleep(i);
cout<<"main: pid = "<<getpid()<<", tid = "<<pthread_self()<<endl;
return 0;
}
pthread_exit函数
退出当前线程
void pthread_exit(void *retval);
参数:
retval:退出值。无退出值 NULL
与其他退出区别:
exit() 表示退出当前进程
return NULL 表示返回到调用者
示例:
pthread_exit(NULL);
pthread_join函数
阻塞等待线程退出
int pthread_join(pthread_t thread, void **retval);
参数:
thread:回收的线程号
retval:目标线程提供的返回值
返回值:
成功:0
失败:error number
示例:
#include <bits/stdc++.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <errno.h>
using namespace std;
struct thrd
{
int var;
string str;
};
void sys_err(const char *str){
perror(str);
exit(1);
}
void* tfn(void* arg){
struct thrd *tval=(struct thrd*)arg;
tval->var=100;
tval->str="hello";
return (void *)tval;
}
int main(int argc,char *argv[]){
pthread_t tid;
struct thrd atval;
struct thrd *retval;
int ret=pthread_create(&tid,NULL,tfn,(void*)&atval);
if(ret!=0){
sys_err("pthread_create error");
}
ret=pthread_join(tid,(void**)&retval);
if(ret!=0){
sys_err("pthread_join error");
}
cout<<"child thread exit with var="<<retval->var<<", str="<<retval->str<<endl;
pthread_exit(NULL);
}
pthread_cancel函数
杀死(取消)一个线程,对应进程中的kill()函数
int pthread_cancel(pthread_t thread);
返回值:
成功:0
失败:errorno
若,线程中没有到达取消点,则pthread_cancel失效,我们需要手动添加取消点,使用 pthread_testcancel()
成功被pthread_cancel杀死的线程,线程返回-1
pthread_detach 函数
实现线程分离,线程主动与主控线程断开关系,可以自己自动释放
int pthread_cancel(pthread_t thread);
检查出错返回:
fprintf(stderr,"phread_detach error: %s\n",strerror(ret))
cout << "Error description: " << strerror(result) << std::endl;
线程出错类型返回
fprintf(stderr,"phread_detach error: %s\n",strerror(ret))
cout << "Error description: " << strerror(result) << std::endl;
线程与进程控制原语对比
线程控制原语 | 进程控制原语 |
---|---|
pthread_create() | fork() |
pthread_self() | getpid() |
pthread_exit() | exit() |
pthread_join() | wait() / waitpid() |
pthread_cancel() | kill() |
pthread_detach() | - |
线程属性
线程属性初始化
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
线程的分离状态
线程的分离状态决定了一个线程以什么样的方式终结自己
设置线程属性,分离 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 exit.
- 避免僵尸线程。
pthread join.
pthread detach.
pthread create. 指定分离属性
被 join 线程可能在 join 函数返回前就释放完自己的所有内存资源,所以不应当返回被回收线程栈中的值; - malloc 和mmap 申请的内存可以被其他线程释放
- 应避免在多线程模型中调用 fork除非,马上 exec,子进程中只有调用 fork 的线程存在,其他线程在子进程A中均 pthread_exit.
- 信号的复杂语义很难和多线程共存,应避免在多线程引入信号机制
线程同步
线程同步,指一个线程发出某一功能调用时,在没有得到结果之前,该调用不返回。同时其它线程为保证数据致性,不能调用该功能。
互斥量 mutex
互斥量mutex属于建议锁!没有强制性,只能通过程序逻辑保证互斥操作(先拿锁、再访问)
主要函数
pthread_mutex_t 锁的结构体
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);创建锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);销毁锁
int pthread_mutex_lock(pthread_mutex_t *mutex);加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);解锁
注意事项:
尽量保证锁的粒度,越小越好(访问共享数据后,立即解锁)
互斥锁的初值为 1(pthread_mutex_init()调用成功)
加锁:--,阻塞线程
解锁:++,唤醒阻塞在锁上的线程
int pthread_mutex_trylock(pthread_mutex_t *mutex);尝试进行加锁
成功 --,失败:返回,设置错误号(EBUSY)
restrict关键字:
用来限定指针变量,被该关键字限定的指针变量所指向的内存操作,必须由本指针完成
读写锁
- 读写锁是“写模式加锁”时,解锁前,所有对该锁加锁的线程都会被阻塞。
- 读写锁是“读模式加锁”时,如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞
- 读写锁是“读模式加锁”时,既有试图以写模式加锁的线程,也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞,写锁优先级高
读写锁只有一把,读写锁也叫共享-独占锁。当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁住时,它是以独占模式锁住的。写独占、读共享。
相较于互斥量而言,当读线程多的时候,效率高
主要函数
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);初始化
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);加读锁
int pthread_rwlock_wdlock(pthread_rwlock_t *rwlock);加写锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);解锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);销毁锁
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);尝试进行加读锁
int pthread_rwlock_trywdlock(pthread_rwlock_t *rwlock);尝试进行加写锁
死锁
是使用锁不当的一种现象
- 对一个锁反复lock
- 两个线程各自持有对方需要的锁
条件变量
条件变量本身本身不是锁,通常要结合锁来使用(mutex)
主要函数
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;静态初始化
int pthread_cond_init(pthread_cond_t *restrict_cond, const pthread_condattr_t *restrict_attr);动态初始化条件变量
int pthread_cond_destroy(pthread_cond_t *cond);销毁
int pthread_cond_wait(pthread_cond_t *restrict_cond, pthread_mutex_t *restrict_mutex);阻塞等待一个条件变量
函数作用:
1.阻塞等待cond
2.释放已掌握的互斥锁
1.2.两步为一个原子操作
3.当被唤醒时,解除阻塞并重新申请互斥锁
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);限时等待一个条件变量
int pthread_cond_signal(pthread_cond_t *cond);唤醒阻塞的一个线程
int pthread_cond_broadcast(pthread_cond_t *cond);广播(唤醒阻塞的多个线程)
生产者、消费者模型(锁)
生产者 | 消费者 |
---|---|
生产数据 | 创建锁 |
加锁 pthread_mutex_lock(&mutex) | 初始化 |
将数据放入公共区域 | 加锁 pthread_mutex_lock(&mutex) |
解锁 pthread_mutex_unlock(&mutex) | 等待满足条件:pthread_cond_wait(&cond,&mutex) 1) 阻塞等待条件变量 2)解锁 ulock(mutex) 3)加锁 lock(mutex) |
通知阻塞在条件变量上的线程 pthread_cond_signal()/pthread_cond_broadcast() | 访问共享数据 |
循环生产后续数据 | 解锁、释放条件变量、释放锁 |
#include <bits/stdc++.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <errno.h>
using namespace std;
//链表作为共享数据,需被互斥量保护
struct msg{
struct msg *next;
int num;
};
struct msg *head;
//静态初始化一个条件变量 一个互斥量
pthread_cond_t has_product=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
void sys_err(const char *str){
perror(str);
exit(1);
}
void* producer(void *p){
struct msg *mp;
for(;;){
mp=new msg();
mp->num=rand()%1000+1;
cout<<"Producer -----"<<mp->num<<endl;
pthread_mutex_lock(&mylock);
mp->next=head;
head=mp;
pthread_mutex_unlock(&mylock);
pthread_cond_signal(&has_product); //唤醒等待的线程
sleep(rand() % 5);
}
}
void* consumer(void *p){
struct msg *mp;
for(;;){
pthread_mutex_lock(&mylock);
while (head == nullptr) //头指针为空,说明没有产品,等待
{
pthread_cond_wait(&has_product,&mylock);
}
mp=head; //模拟消费一个产品
head=head->next;
pthread_mutex_unlock(&mylock);
cout<<"Consumer id="<<pthread_self()<<"---"<<mp->num<<endl;
delete(mp);
sleep(rand() % 5);
}
}
int main(int argc,char *argv[]){
pthread_t pid,cid;
srand(time(NULL));
pthread_create(&pid,NULL,producer,NULL);
pthread_create(&cid,NULL,consumer,NULL);
pthread_create(&cid,NULL,consumer,NULL);
pthread_create(&cid,NULL,consumer,NULL);
pthread_join(pid,NULL);
pthread_join(cid,NULL);
return 0;
}
信号量
相当于初始化值为 N 的互斥量,表示可以同时访问共享数据的线程数
可以应用于线程和进程同步
sem_t sem
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数:
sem:信号量
pshared:
0:用于线程间同步
非0:用于进程间同步
value:同时访问线程数
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
信号量 >0 --
信号量 =0 线程阻塞
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
int sem_post(sem_t *sem);
信号量 <N ++,同时唤醒阻塞在信号量上的线程
信号量 >N 阻塞
头文件:
#include <semaphore.h>
生产者、消费者模型(信号量)
#include <bits/stdc++.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>
using namespace std;
//链表作为共享数据,需被互斥量保护
struct msg{
struct msg *next;
int num;
};
struct msg *head;
sem_t blank_num,product_num;
void sys_err(const char *str){
perror(str);
exit(1);
}
void* producer(void *p){
struct msg *mp;
for(;;){
sem_wait(&blank_num);
mp=new msg();
mp->num=rand()%1000+1;
cout<<"Producer -----"<<mp->num<<endl;
sem_post(&product_num);
mp->next=head;
head=mp;
sleep(rand() % 5);
}
}
void* consumer(void *p){
struct msg *mp;
for(;;){
sem_wait(&product_num);
mp=head; //模拟消费一个产品
head=head->next;
cout<<"Consumer id="<<pthread_self()<<"---"<<mp->num<<endl;
sem_post(&blank_num);
delete(mp);
sleep(rand() % 5);
}
}
int main(int argc,char *argv[]){
pthread_t pid,cid;
srand(time(NULL));
sem_init(&blank_num,0,5); //初始化信号量
sem_init(&product_num,0,0);
pthread_create(&pid,NULL,producer,NULL);
pthread_create(&cid,NULL,consumer,NULL);
// pthread_create(&cid,NULL,consumer,NULL);
// pthread_create(&cid,NULL,consumer,NULL);
pthread_join(pid,NULL);
pthread_join(cid,NULL);
sem_destroy(&blank_num);
sem_destroy(&product_num);
return 0;
}