线程同步与互斥

mutex互斥量

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程。
但有时候很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
多个线程并发的操作共享变量，会带来一些问题。

举个妮子：

#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>
//共享变量（票数）
int ticket = 6;
//线程要做的事（买票）
void *route(void *arg)
{
    char *id = (char*)arg;
    while(1)
    {
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n",id,ticket);
            //每被某一个线程买走一张票，票数要-1
            ticket--;
        }
        else
        {
            break;
        }
    }
    return NULL;
}

int main()
{
    pthread_t t1,t2,t3;

    pthread_create(&t1,NULL,route,"thread 1");
    pthread_create(&t2,NULL,route,"thread 2");
    pthread_create(&t3,NULL,route,"thread 3");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);
}

测试结果如下：

我们可以看到一个非常明显的错误，当票数已经没有了的时候，某些线程依然买到了票。那么这又是为什么呢？

1、if 语句判断为真以后，代码可以并发的切换到其他线程
2、usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该段代码
3、- - ticket 操作本身就不是一个原子操作

说一下- - ticket：该条语句事实上是对应了3个步骤。第一步是将共享变量ticket从内存加载到寄存器中，第二步更新寄存器的值，执行-1操作，第三步将新值从寄存器写回共享变量ticket的内存地址。

要解决上面说到的这些问题，需要做到以下3点：

1、代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区
2、如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区
3、如果线程不再临界区执行，那么该线程不能阻止其他线程进入临界区。

要想做到这3点解决问题，只需要用一把锁即可，Linux上提供的这把锁叫互斥量

下面我们来看一看关于操作互斥量的一些接口

初始化互斥量

//方法1：静态分配
pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;


//方法2：动态分配
int  pyhread_mutex_init（pthread_mutex_t  *restrict  mutex，const  pthread_mutexattr_t  *restrict attr）;
//参数mutex：要初始化的互斥量
//attr：NULL

销毁互斥量

int pthread_mutex_destroy(pthread_mutex_t *mutex);
//注意：使用PTHREAD_MUTEX_INITIALIZER初始化的互斥量不需要销毁
//不要销毁一个已经加锁的互斥量
//已经销毁的互斥量，要确保后面不会有线程在尝试加锁

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//返回值：成功返回0，失败返回错误码

当我们加锁时（调用pthread_mutex_lock）可能会遇到的一些情况：

1、互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功（返回0）
2、发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_mutex_lock调用会陷入阻塞。等待互斥量解锁

现在我们将上面的售票改进一下看看效果：

int ticket = 10;
pthread_mutex_t mutex;

void *route(void *arg)
{
    char *id = (char*)arg;
    while(1)
    {
        //加锁
        pthread_mutex_lock(&mutex);
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n",id,ticket);
            ticket--;
            //解锁
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            //解锁
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return NULL;
}

int main()
{
    pthread_t t1,t2,t3;

    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);

    pthread_create(&t1,NULL,route,"thread 1");
    pthread_create(&t2,NULL,route,"thread 2");
    pthread_create(&t3,NULL,route,"thread 3");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);

    //销毁互斥量
    pthread_mutex_destroy(&mutex);
}

测试结果如下：（该进程中有3个线程买票，至于哪一个买到是不确定的，多运行几次可以看到是每一次买票都是随机的其中一个线程）

条件变量

接下来要讨论的的条件变量，主要用来实现线程之间的同步。

当一个线程互斥的访问某个变量时，他可能发现在其他线程改变状态之前，他什么也做不了。比如说一个线程访问队列时，刚好这个队列为空队列，他只能等待，直到其他线程将一个节点添加到队列中，这种情况下就需要用到条件变量。

条件变量函数

初始化条件变量

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
//参数cond:要初始化的条件变量
//attr:NULL

销毁条件变量

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 <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>

pthread_cond_t cond;
pthread_mutex_t mutex;

void *r1(void *arg)
{
    while(1)
    {
        pthread_cond_wait(&cond,&mutex);
        printf("活动\n");
    }
}

void *r2(void *arg)
{
    while(1)
    {
        pthread_cond_signal(&cond);
        sleep(1);
    }
}

int main()
{
    pthread_t t1,t2;
    pthread_cond_init(&cond,NULL);
    pthread_mutex_init(&mutex,NULL);

    pthread_create(&t1,NULL,r1,NULL);
    pthread_create(&t2,NULL,r2,NULL);

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

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

测试结果如下：

接下来我们来说一下上面介绍等待条件满足的函数时，遗留的一个问题。为什么pthread_cond_wait 需要互斥量。

条件等待是线程间同步的一种手段，如果只有一个线程，条件不满足，一直等待下去都不会满足，所以必须要有一个线程通过某些操作改变共享变量，使原先不满足的条件变得满足，并且友好的通知等待在条件变量上的线程。
条件不会无缘无故的突然变得满足了，必然会牵扯到共享数据的变化，所以一定要用互斥锁来保护，没有互斥锁就无法安全的获取和修改共享数据。

//错误的设计
pthread_mutex_lock(&mutex);
while(1)
{
    pthread_mutex_unlock(&mutex);
    //解锁之后，等待之前，条件可能已经满足，信号已经发出，但是该信号可能被错过
    pthread_cond_wait(&cond);
    pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);

1、 由于解锁和等待不是原子操作。调用解锁之后，pthread_cond_wait之前，如果已经有其他线程获取到互斥量，摒弃条件满足发送了信号，那么pthread_cond_wait将错过这个信号，可能会导致线程永远阻塞在这个pthread_cond_wait。所以解锁和等待必须是原子操作。
2、 int pthread_cond_wait（pthread_cond_t *cond， pthread_mutex_t *mutex）；进入该函数，会去看条件变量是否等于0，等于就把互斥量变成1，直到cond_wait返回，把条件变量变成1，被互斥量恢复成原样（0）。

条件变量使用规范：

//等待条件代码：
pthread_mutex_lock(&mutex)；
while（条件为假）
{
    pthread_cond_wait(cond,mutex)；
}
修改条件（互斥量变为1）
pthread_mutex_unlock(&mutex)；


//给条件发送信号代码：
pthread_mutex_lock(&mutex)；
设置条件为真（并且把互斥量恢复原样也就是0）
pthread_cond_signal(cond)；
pthread_mutex_unlock(&mutex)；