[Linux]多线程（线程互斥、线程同步部分）

目录

Linux线程互斥

进程线程间的互斥相关背景概念

互斥量mutex

互斥量实现原理探究

可重入和线程安全

概念介绍

常见的线程不安全情况:

常见的线程安全情况

常见不可重入的情况

常见可重入的情况

可重入与线程安全的关系

可重入与线程安全区别

常见锁概念

死锁

死锁的四个必要条件

避免死锁

Linux线程同步

同步概念与竞态条件

条件变量

条件变量函数

条件变量的使用规范

Linux线程互斥

进程线程间的互斥相关背景概念

• 临界资源：多线程执行流共享的资源就叫做临界资源

• 临界区：每个线程内部，访问临界资源的代码，就叫做临界区

• 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

• 原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

临界资源和临界区---

        进程间通信，我们需要看到同一份第三方资源（管道、共享内存等），而这些能被不同进程共享的资源就是临界资源，访问临界资源的代码就叫做临界区。

        线程间通信就容易多了，大多的资源本身就是共享的。

接下来我们让主线程对全局变量count++,新线程打印count。

#include
#include
#include
using namespace std;
//创建一个临界资源
int count = 0;

void* routine(void* msg)
{
    //打印count
    while(true)
    {
        cout<

 其中，count就是临界资源，count++和cout等就是临界区。

互斥和原子性----

让我们设想一个情况，多个线程同时对同一份临界资源进行操作，会不会出现什么问题呢？

接下来将通过一个抢票程序来展示：

#include
#include
#include
using namespace std;

//有1000张票待抢
int ticket = 1000;

void* routine(void* msg)
{
    while(ticket>0)  //剩余票数大于0就一直抢票
    {
        usleep(1000);
        ticket--;
        printf("%s get ticket : %d\n",(char*)msg,ticket);
    }
    return nullptr;
}

int main()
{
    pthread_t tid[4];  //创建四个新线程一起抢票
    //创建新线程
    for(int i=0;i<4;++i)
    {
        char* buff = new char[32];
        snprintf(buff,sizeof(buff),"thread%d",i);
        pthread_create(tid+i,nullptr,routine, buff);
    }

    //线程等待
    for(int i=0;i<4;++i)
    {
        pthread_join(tid[i],nullptr);
    }

    return 0;
}

 

        震惊，居然抢出了负数的票数。很明显，这是不允许出现的情况。我们该如何解决该问题呢？

        首先，该代码中的ticket是我们的临界资源，（判断ticket>0，ticket--,printf打印ticket）等都是临界区，因为这些代码访问了临界资源。

出现负数票数的原因：

1. 判断ticket>0后，cpu可能切换了其他的线程，当前线程被挂起了。

2. usleep模拟了漫长业务的过程，在这期间，临界资源ticket会被很多其他线程访问。

3. ticket-- 不是一个原子操作。

ticket--为何不是原子操作-----

下面我们来看ticket--部分的汇编代码：

 发现进行了三次操作。

-- 操作并不是原子操作，而是对应三条汇编指令：

• load ：将共享变量ticket从内存加载到寄存器中

• update : 更新寄存器里面的值，执行-1操作

• store ：将新值，从寄存器写回共享变量ticket的内存地址

 假设我们完成第一步后将当前执行流切走，寄存器内的上下文保存在当前线程的上下文中。

 由于线程1对ticket-- 的操作只进行了第一步，还没来得及将处理完成后的数据返回给内存，此时内存中ticket的数量仍然是1000. 此时再让切换到的线程2对ticket-- 200次。

 完成后内存中的ticket变成了800，此时我们再让线程1回来继续执行

 

        这时就出现了令人哭笑不得的情况，票数从800变成了999，无中生有了200张票。

        因而++ ，-- 等操作都不是原子的，进行一次操作需要三行汇编，当一个操作只需要一行汇编时，我们就可以说该操作是原子的。

        如何解决这些问题呢？ 我们可以进行加锁。让该操作在未被执行完前，其余线程无法对其进行操作。

互斥量mutex

• 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

• 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

• 多个线程并发的操作共享变量，会带来一些问题。

要解决上面抢票系统的问题，需要做到三点：

• 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

• 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

• 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

互斥量的接口----

初始化互斥量

初始化互斥量有两种方法：

方法1，静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

方法2，动态分配:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
const pthread_mutexattr_t *restrictattr);

参数：

• mutex：要初始化的互斥量.

• attr：初始化互斥量的属性，一般设置为NULL即可.

返回值：

• 成功返回0，失败返回错误码

销毁互斥量

销毁互斥量需要注意：

• 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁

• 不要销毁一个已经加锁的互斥量

• 已经销毁的互斥量，要确保后面不会有线程再尝试加锁

销毁互斥量的函数：

int pthread_mutex_destory(pthread_mutex_t *mutex);

参数：

• mutex 待销毁的互斥量

返回值

• 销毁成功返回0，销毁失败返回错误码

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//返回值:成功返回0,失败返回错误号

调用 pthread_ lock 时，可能会遇到以下情况:

• 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功。

• 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

接下来就开始改进我们之前写的卖票程序：

#include
#include
#include
using namespace std;

//有1000张票待抢
int ticket = 1000;
//静态方式
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER ;

void* routine(void* msg)
{
    while(true)  //剩余票数大于0就一直抢票
    {
        //
        pthread_mutex_lock(&mutex);
        if(ticket>0)
        {
        usleep(1000);
        printf("%s get ticket : %d\n",(char*)msg,ticket);  
        ticket--;
            pthread_mutex_unlock(&mutex);      
        }
        else
        {
            pthread_mutex_unlock(&mutex);      
            break;
        }
    }
    printf("%s退出\n",(char*)msg);
    pthread_exit((void*)1);
    
}

int main()
{
    pthread_t tid[4];  //创建四个新线程一起抢票
    //创建新线程
    for(int i=0;i<4;++i)
    {
        char* buff = new char[32];
        snprintf(buff,sizeof(buff),"thread%d",i);
        pthread_create(tid+i,nullptr,routine, buff);
    }
    //线程等待
    for(int i=0;i<4;++i)
    {
        pthread_join(tid[i],nullptr);
    }
    return 0;
}

 

 

这次成功正确的抢了票。

注意点：

• 加锁会导致性能下降，因为多执行流由并行变成了串行执行

• 我们要让加锁的代码部分尽可能的小。减少加锁对程序效率的影响。

互斥量实现原理探究

 

• 经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题

• 为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。

 

 

 

 把lock和unlock的伪代码改一下,我们能更清楚的看出来:

 

可重入和线程安全

概念介绍

• 线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。

• 重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

常见的线程不安全情况:

• 不保护共享变量的函数

• 函数状态随着被调用，状态发生变化的函数

• 返回指向静态变量指针的函数

• 调用线程不安全函数的函数

常见的线程安全情况

• 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的

• 类或者接口对于线程来说都是原子操作

• 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

• 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的

• 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构

• 可重入函数体内使用了静态的数据结构

常见可重入的情况

• 不使用全局变量或静态变量

• 不使用用malloc或者new开辟出的空间

• 不调用不可重入函数

• 不返回静态或全局数据，所有数据都有函数的调用者提供

• 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全的关系

• 函数是可重入的，那就是线程安全的

• 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题

• 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

• 可重入函数是线程安全函数的一种。

• 线程安全不一定是可重入的，而可重入函数则一定是线程安全的。

• 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

常见锁概念

死锁

• 死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

死锁的四个必要条件

• 互斥条件：一个资源每次只能被一个执行流使用

• 请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放

• 不剥夺条件:一个执行流已获得的资源，在末使用完之前，不能强行剥夺

• 循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系

常见的死锁情况：

• 同一把锁申请了两次

#include
#include
#include
pthread_mutex_t mutex;

void* start_routine(void* msg)
{
    pthread_mutex_lock(&mutex);   //申请了两次，导致死锁
    pthread_mutex_lock(&mutex);
    std::string _msg = static_cast(msg);
    std::cout<< _msg <

 

 

        用命令ps查看该进程时可以看到，该进程当前的状态是Rl+，其中的l实际上就是lock的意思，表示该进程当前处于一种死锁的状态。

• 两个线程都各自有锁，但向对方要锁

        除非一个线程主动释放掉自己本身的锁，不然就会死锁

 

避免死锁

• 破坏死锁的四个必要条件

• 加锁顺序一致

• 避免锁未释放的场景

• 资源一次性分配

除此以外，还有避免死锁的算法，如死锁检测算法、银行家算法等。

Linux线程同步

同步概念与竞态条件

• 同步：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，叫做同步。

• 竞态条件：因为时序问题，而导致程序异常，我们称之为竞态条件。

首先我们来看一个现象，依然是我们的抢票程序

 

        我们发现抢票时全是一个线程在抢票，其余线程一直在挂起等待，为何？

        线程2的竞争力特别强，每次都能够申请到锁，所以在我们看来这个线程就一直在申请锁和释放锁，这就可能导致其他线程长时间竞争不到锁，引起饥饿问题.

        很明显，这种现象是不符合我们的一般认知的，为了解决这种问题，我们就需要同步了。

        我们可以设想有一个队列，线程都在其中排队，当一个线程解锁后如果再想申请锁就需要排到队列后，这样就让每个线程按顺序的访问临界资源了。

条件变量

• 当一个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了。

• 例如一个线程访问队列时，发现队列为空，它只能等待，直到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

条件变量函数

初始化条件变量：

静态分配：

pthread_cond_t cond = PTHREAD_COND_INITAiLIZER;

动态分配：

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict
attr);

参数：

• cond：要初始化的条件变量

• attr：初始化条件变量的属性，一般设置为空。

返回值：

条件变量初始化成功返回0，失败返回错误码

销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond)；

静态分配的就不需要调用它了。

等待条件满足：

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);

参数：

• cond：要在这个条件变量上等待

• mutex：互斥量，当前线程申请的锁

唤醒等待：

//唤醒等待的所有线程
int pthread_cond_broadcast(pthread_cond_t *cond);
//唤醒等待的第一个线程
int pthread_cond_signal(pthread_cond_t *cond);

接下来让我们修改一下抢票程序：

#include
#include
#include
#include
using namespace std;

//有1000张票待抢
int ticket = 1000;
//静态方式
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER ;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* routine(void* msg)
{
    string _msg = static_cast(msg);
    while(true)  //剩余票数大于0就一直抢票
    {
        //
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        if(ticket>0)
        {
        cout<<_msg<<"---->"<

将pthread_cond_signal 换成 pthread_cond_broadcast,一次打印一批.

 

为什么pthread_cond_wait需要互斥量

• 条件等待是线程间同步的一种手段，如果只有一个线程，条件不满足，一直等下去都不会满足，所以必须要有一个线程通过某些操作，改变共享变量，使原先不满足的条件变得满足，并且友好的通知等待在条件变量上的线程。

• 条件不会无缘无故的突然变得满足了，必然会牵扯到共享数据的变化。所以一定要用互斥锁来保护。没有互斥锁就无法安全的获取和修改共享数据。

条件变量的使用规范

• 等待条件代码

pthread_mutex_lock(&mutex);
while (//条件为假）
pthread_cond_wait(cond, mutex);
//修改条件
pthread_mutex_unlock(&mutex);

• 给条件发送信号代码

pthread_mutex_lock(&mutex);
//设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);

有关线程同步还有一些细节，那一部分会在下篇Linux博客（生产者消费者模型中提及）。