线程的同步与互斥

之所以会引出这个概念全都是因为 “线程之间是抢占式调度的”。

关于线程互斥的一下关键词：

• 临界资源：多个线程访问的那个公共资源叫做临界资源。
• 临界区：访问临界资源的代码叫做临界区。
• 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
• 原子性：不会被任何调度机制打断的操作，该操作只有两种状态，要么完成，要么未完成。
• 线程不安全：多线程环境下程序的执行结果出现预期之外的值。

引入互斥的意义：

• 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
• 有些时候有一些变量需要在线程间共享，这样的变量称为共享变量（也就是上面说的临界资源），可以通过数据的共享，完成线程之间的交互。

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

这里我来举个栗子????

int count = 0;

void *ThreadEntry(void *arg)
{
    (void)arg;

    for (int i = 0; i < 50000; i++)
    {
        count++;
    }

    return nullptr;
}

int main(void)
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, nullptr, ThreadEntry, nullptr);
    pthread_create(&tid2, nullptr, ThreadEntry, nullptr);

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);

    std::cout << count << std::endl;

    return 0;
}

我们的期望是输出 100000。但是结果如何呢？

只有一次输出了 100000 。

原因：因为 ++ 操作不是一步就执行完了，也就是说 ++ 不是一个源自操作，++ 操作有三个步骤：

1. 把变量从内存中加载到CPU中。
2. 执行 ++。（是对寄存器中的数据 ++）
3. 在吧CPU中的值写回内存中。

因为线程是抢占式执行，如果线程1只是把变量加载到CPU中，甚至对寄存器中的数据进行了++操作，但是还没把数据写回内存的时候，线程2把内存中的数据加载到CPU中，这个时候，虽然执行了两次 ++，但是值只是 ++ 了一次。

那么应该怎么办呢？这里就引入锁！

互斥量

Linux 上提供的锁叫互斥量。

互斥机制的使用：

1. 先加锁。
2. 执行临界区代码。
3. 释放锁。

互斥量的接口

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

1. 静态分配

   pthread_mutex__t mutex = PTHREAD_MUTEX_INITIALIZER;

2. 动态分配

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

   参数：

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

   • attr：nullptr。

互斥量销毁：

上图中也包含了互斥量的销毁。

参数：

• mutex：互斥量的地址。

互斥量加锁和解锁：

参数：

三个函数都是互斥量的地址。这里说一下 trylock()

因为加锁的时候会先判断一下当前位置有没有锁，如果有，就获取不到锁，lock的做法是阻塞等待。而trylock的做法是若获取不到当前的锁，就不要这个锁去找另一个锁。

这就是可以让本应该阻塞等待的线程去干别的事情。可以用轮询的方式。

返回值：

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

修改上面代码，重看现象：

int count = 0;
pthread_mutex_t mutex;

void *ThreadEntry(void *arg)
{
    (void)arg;
    
    for (int i = 0; i < 50000; i++)
    {
        pthread_mutex_lock(&mutex);
        count++;
        pthread_mutex_unlock(&mutex);
    }

    return nullptr;
}

int main(void)
{
    pthread_mutex_init(&mutex, nullptr);

    pthread_t tid1, tid2;
    pthread_create(&tid1, nullptr, ThreadEntry, nullptr);
    pthread_create(&tid2, nullptr, ThreadEntry, nullptr);

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    
    pthread_mutex_destroy(&mutex);

    std::cout << count << std::endl;

    return 0;
}

不管运行几次，我们都可以得到我们想要的结果。

经过测试，c++ std命名空间里提供的锁同样也可以提供线程安全。

int count = 0;
std::mutex mutex;

void *ThreadEntry(void *arg)
{
    (void)arg;
    
    for (int i = 0; i < 50000; i++)
    {
        mutex.lock();
        count++;
        mutex.unlock();
    }

    return nullptr;
}

Linux 线程同步

首先这里说一个原则：同步和互斥是两个东西。

同步指的是顺序上的同时，同步控制着线程和线程之间的执行顺序（主要还是线程的抢占式调度惹的祸，有的时候就是需要线程和线程之间按照一定的顺序执行。）

条件变量

举个栗子????:

比如说两个人在吃饭（这里代表两个线程），一个人吃饭，一个人端饭。如果端饭的人动作很慢，吃饭的人动作很快。不管怎么样，吃饭的人都得等端饭的人把饭端过来了才能吃嘛，总不能吃空气吧。所以这个过程就是条件变量。一个线程等待另一个线程把一件事干完了，这个线程才能开始干活。

同步概念和竞态条件

• 同步：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效的避免了线程饿死。（线程饿死就是某个线程一直得不到CPU资源而不被调度）。
• 竞态条件：因为时序问题，而导致程序异常。

条件变量函数

pthread_cond_init / pthread_cond_destroy:

同样的对于条件变量可以静态初始化也可以动态初始化。

参数：

• cond：条件变量。
• attr：nullptr。

pthread_cond_wait

参数：

• cond：条件变量。
• mutex：互斥量。

这个函数是一个阻塞等待，直到另一个线程发送一个通知。

这个函数有三个步骤：

1. 释放锁。
2. 等待条件就绪。
3. 重新获取锁，准备执行后续的操作。

pthread_cond_signal / pthread_cond_broadcast

参数：

• cond：条件变量。

这两个函数就是在给等待线程发信号，让等待的线程得以执行。

举个栗子????

先看看不加条件变量的结果

#include <unistd.h>
// 同步练习
pthread_mutex_t mutex;
pthread_cond_t cond;

void *Waiter(void *arg)
{
    (void) arg;

    while (true)
    {
        std::cout << "端菜" << std::endl;
        usleep(888888);
    }

    return nullptr;
}

void *Guest(void *arg)
{
    (void) arg;

    while (true)
    {
        std::cout << "吃饭" << std::endl;
        usleep(333333);
    }
    return nullptr;
}

int main(void)
{
    pthread_t tid1, tid2;

    pthread_mutex_init(&mutex, nullptr);
    pthread_cond_init(&cond, nullptr);

    pthread_create(&tid1, nullptr, Waiter, nullptr);
    pthread_create(&tid2, nullptr, Guest, nullptr);

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

这里，每端一次菜就吃好几次饭，按理说我们要的结果是端一次菜吃一次饭。

那么再看看加了条件变量的结果。

void *Waiter(void *arg)
{
    (void) arg;

    while (true)
    {
        std::cout << "端菜" << std::endl;

        pthread_cond_signal(&cond);

        usleep(888888);
    }

    return nullptr;
}

void *Guest(void *arg)
{
    (void) arg;

    while (true)
    {
        pthread_cond_wait(&cond, &mutex);

        std::cout << "吃饭" << std::endl;
        usleep(333333);
    }
    return nullptr;
}

这下就达到了我们想要的结果。

为什么pthread_cond_wait需要互斥量

之所以这个函数需要互斥量，是因为怕线程错过其他线程的通知消息，导致一直等，所以这两个操作必须是原子的。

解释一下

• 比如两个线程都要访问一个共享资源，那么这个共享资源是不是就需要加锁。
• 如果等待的函数先获取了锁，那么另一个发信号的线程需要获取锁怎么办，那就得需要收信号的线程在wait函数的时候释放锁，等待发信号的线程访问完临界资源之后发信号。
• 如果，在等待函数前先释放锁，那么同时发信号的线程发送了信号。那么还没来得及进入等待函数信号已经错过了，那这不就会一直等待嘛。
• 所以就需要这个解锁和等待的动作是原子的，所以这个函数就需要这个互斥量。然后再函数内部，程序设计者会用一些原子的指令来完成这两个操作。