Linux——多线程中的同步与互斥

作者： 小 琛
欢迎转载，请标明出处

一个多线程程序的设计

互斥+同步(如果需要)

互斥：保证同一个时刻，只有一个执行流在访问临界资源。
同步：保证多个执行流对临界资源访问的合理性。

从内核角度解析互斥与同步存在的意义

互斥——保证资源访问的安全

多线程区别于多进程：在内核中是并行的，同时拥有相同的虚拟地址空间，从而拥有相同的数据。

假设某时刻，两个线程A和线程B都在访问一个共有的变量X，同时对X进行加1操作，由于并行运行的原因，导致本该被加两次的X只被加了一次。

因此，我们需要一把“锁”，这把锁可以实现对一个临界资源访问权的控制，即当一个执行流对某个临界资源进行操作的时候，锁住该临界资源，让其它执行流无法访问，直到开锁。

同步——保证资源访问的合理

假设有这样的两个线程，一个线程负责生产变量x，一个线程消耗变量x。

根据我们上面了解的互斥原理，在某一个线程访问资源x的时候，要加锁保证互斥。
某时刻：消耗线程访问临界资源x，发现x消耗殆尽，无法再继续提供服务；或生产线程访问临界资源x，发现x余量充足，不需要生产。那么就这个时刻而言，线程访问临界资源就已经不合理了。 这就说明了，如果不加以管理，很容易造成需要生产x的时候消耗线程在访问x；需要消耗x的时候，生产线程在访问x。

因此，我们需要一个条件变量，它可以实现当x充足的时候，让消耗x的线程访问资源；当x消耗殆尽的时候，让生产x的线程访问资源。
即：令某时刻临界资源自身情况贴合线程期望执行的操作，以达到对临界资源访问的合理化。

帮助理解，例子：吃面条

互斥与同步的实现接口函数

互斥：

定义互斥锁
pthread_mutex_t ：//互斥锁变量类型

初始化互斥锁
int pthread_mutex_init (pthread_mutex_t* mutex, pthread_mutexattr_t * attr);
mutex: 传入互斥锁变量的地址
attr：设置互斥锁属性，通常我们使用默认属性传入NULL

加锁
阻塞加锁：
int pthread_mutex_lock(pthread_mutex_t* lock)
非阻塞加锁：
int pthread_mutex_trylock(pthread_mutex_t* lock)
规则：如果互斥锁当中计数器的值为1，则表示可以加锁，正常调用；如果互斥锁当中的计数器值为0，表示不可以加锁，报错返回。
带有超时时间的加锁
int pthread_mutext_timelock(pthread_mutex_t* lock，const struct timespec*)
规则：当加锁时，若当前资源被其它执行流占用，则等待规定时间，若仍无法获取锁资源，报错返回
解锁
int pthread_mutex_unlock(pthread_mutex_t* lock)
执行流，不论采用哪种方式加锁，都可以调用该接口进行解锁。

摧毁互斥锁
int pthread_mutex_destory(pthread_mutex_t* lock)
释放动态初始化的互斥锁变量，防止内存泄漏

同步：

定义：pthread_cond_t

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

等待接口
int pthread_cond_wait(pthread_cond_t* cond,pthread_mutex_t* mutex)
cond：传入的条件变量的地址
mutex：传入的互斥锁变量的地址

唤醒接口
int pthread_cond_signal(pthread_cond_T* cond) -》唤醒至少一个PCB等待队列中的线程
cond:传入的条件变量的地址
int pthread_cond_broadcast(pthread_cont* cond) -》唤醒所有等待线程

销毁
int pthread_cond_destroy(pthread_cond_t* cond)

代码实现吃面条

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define THREADCOUNT 2
//0代表当前碗里没有面
//1代表碗里有面
int g_noodle = 0;

pthread_mutex_t lock;
pthread_cond_t consume_cond;
pthread_cond_t product_cond;

void* ConsumeStart(void* arg)
{
    (void)arg;
    while(1)
    {
        pthread_mutex_lock(&lock);
        while(g_noodle == 0)
        {
            //阻塞等
            //1.将该PCB放到PCB等待队列当中去
            //2.解锁
            //3.等待被唤醒
            pthread_cond_wait(&consume_cond, &lock);
        }
        g_noodle--;
        printf("i am Consumer i Consume %d\n", g_noodle);
        pthread_mutex_unlock(&lock);
        //通知厨子，有可能在唤醒之后，还是厨子拿到了互斥锁，判断了碗里还是有面的，所以厨子被放到了PCB等待队列当中去了，所以说我们需要吃碗面的时候，通知一下PCB等待队列当中的线程
        pthread_cond_signal(&product_cond);
    }
    return NULL;
}

void* ProductStart(void* arg)
{
    (void)arg;
    while(1)
    {
        pthread_mutex_lock(&lock);
        while(g_noodle == 1)
        {
            pthread_cond_wait(&product_cond, &lock);
        }
        g_noodle++;
        printf("i am Producer i product %d\n", g_noodle);
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&consume_cond);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&consume_cond, NULL);
    pthread_cond_init(&product_cond, NULL);
    pthread_t Consume_tid[THREADCOUNT];
    pthread_t Product_tid[THREADCOUNT];
    //pthread_t tid[2];
    int i = 0;
    int ret = -1;
    for(; i < THREADCOUNT; i++)
    {
        ret = pthread_create(&Consume_tid[i], NULL, ConsumeStart, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for(i = 0; i < THREADCOUNT; i++)
    {
        ret = pthread_create(&Product_tid[i], NULL, ProductStart, NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for(int i = 0; i < THREADCOUNT; i++)
    {
        pthread_join(Consume_tid[i], NULL);
        pthread_join(Product_tid[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&consume_cond);
    pthread_cond_destroy(&product_cond);
    return 0;
}