Linux-线程的同步与互斥：互斥量，条件变量，读写锁，屏障

最新推荐文章于 2022-11-23 18:43:56 发布

mxrrr_sunshine

最新推荐文章于 2022-11-23 18:43:56 发布

阅读量400

点赞数 1

分类专栏： Linux Linux基础学习

本文链接：https://blog.csdn.net/mxrrr_sunshine/article/details/80028618

版权

Linux 同时被 2 个专栏收录

41 篇文章 0 订阅

订阅专栏

Linux基础学习

40 篇文章 2 订阅

订阅专栏

同步与互斥

先来说说为什么线程需要同步与互斥机制。

如果每个线程使用的变量都是其他线程不会读取和修改的，那么就不存在一致性问题。同样，如果变量是只读的，多个线程同时读取该变量也不会有一致性问题。但是，当一个线程可以修改的变量，其他线程也可以读取和修改的时候，我们就需要对这些线程进行同步，确保他们再访问变量的存储内容时不会访问到无效的值。
假设两个线程读写相同变量时，线程A读取变量然后给这个变量赋予一个新的值，但写操作需要两个存储周期。当线程B在这两个写周期读取这个变量时，可能会得到不一致的值。为了避免这个问题，就需要互斥，同一时间只允许一个线程访问该变量。

互斥量

假设一个场景，我们新建几个新线程，每个线程都去购票，对全局变量ticket进行减1操作，我们来看看会出现什么情况。
参考下面的代码：

int ticket=100;
void* Buy_Ticket(void* arg)
{
    char* id=(char*)arg;
    while(1)
    {
        if(ticket>0)
        {
            usleep(1000);
            printf("%s sells ticket: %d\n",id,ticket);
            ticket--;
        }
        else
        {
            break;
        }
    }

}
int main()
{
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,NULL,Buy_Ticket,(void**)"thread 1");
    pthread_create(&t2,NULL,Buy_Ticket,(void**)"thread 2");
    pthread_create(&t3,NULL,Buy_Ticket,(void**)"thread 3");
    pthread_create(&t4,NULL,Buy_Ticket,(void**)"thread 4");

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

这里写图片描述
我们发现这个结果竟然会卖出-2张票，显然这是不合理的。
原因是由于，对全局变量ticket做减1操作并不是原子的。通常分为以下3步进行。

从内存中读入cpu寄存器
在寄存器中对变量进行减运算
把新的值写回内存

如果第一个线程刚把数据写入cpu减1变成99之后，被切换，后来的线程都来允许，直到将所有票卖光，第一个线程此时被切换回来，再将之前的数据写回内存，当然数据就会不一致了。
所以，为了解决这个问题，就要做到以下三点：
- 代码必须要有互斥行为，当代码进入临界区，不允许其他进程进入临界区。
- 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入临界区。
- 如果线程不在临界区执行，那么该线程不能阻止其他进程进入临界区。
满足以上三点的，实质上就是一把锁，linux给我们提供的这把锁叫做互斥量。
接口介绍如下：

初始化互斥量：
动态方式：int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
静态分配： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
销毁互斥量：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
加锁：
int pthread_mutex_lock(pthread_mutex_t *mutex);
解锁：
int pthread_mutex_unlock(pthread_mutex_t *mutex);

然后我们修改刚才的代码：

int ticket=100;
pthread_mutex_t mutex;
void* Buy_Ticket(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;
        }
    }

}
int main()
{
    pthread_t t1,t2,t3,t4;
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&t1,NULL,Buy_Ticket,(void**)"thread 1");
    pthread_create(&t2,NULL,Buy_Ticket,(void**)"thread 2");
    pthread_create(&t3,NULL,Buy_Ticket,(void**)"thread 3");
    pthread_create(&t4,NULL,Buy_Ticket,(void**)"thread 4");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);
    pthread_join(t4,NULL);
    pthread_mutex_destroy(&mutex);
}

条件变量：

void* route_t1(void* arg)
{
    while(1)
    {

        printf("i am thread A\n");
    }
}
void* route_t2(void* arg)
{
    while(1)
    {

        printf("i am thread B\n");
        sleep(1);
    }
}
int main()
{
    pthread_t t1,t2;

    pthread_create(&t1,NULL,route_t1,(void**)"thread 1");
    pthread_create(&t2,NULL,route_t2,(void**)"thread 2");

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



}

再来看结果：

这里写代码片

总结：互斥量是为了实现互斥

条件变量

为了实现同步，所以需要条件变量。

条件变量给多个线程提供了一个会和的场所。条件变量与互斥量一起使用时，允许线程以无竞争方式等待待定的条件发生。

当一个线程互斥地访问某个变量时，他可能发现在其他线程改变状态之前，他什么也做不了。可以让他该线程在某个条件变量上等待，直到这个条件一旦成熟，就唤醒该线程。
介绍接口：

初始化条件变量：
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
销毁条件变量：
int pthread_cond_destroy(pthread_cond_t *cond);
等待条件满足：
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
唤醒：
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

下面是未使用条件变量的例子：

pthread_cond_t cond;
pthread_mutex_t mutex;
void* route_t1(void* arg)
{
    while(1)
    {
        pthread_cond_wait(&cond,&mutex);
        printf("i am thread A\n");
    }
}
void* route_t2(void* arg)
{
    while(1)
    {
        pthread_cond_signal(&cond);
        printf("i am thread B\n");
        sleep(1);
    }
}
int main()
{
    pthread_t t1,t2;
    pthread_cond_init(&cond,NULL);
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&t1,NULL,route_t1,(void**)"thread 1");
    pthread_create(&t2,NULL,route_t2,(void**)"thread 2");

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

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

}

这里写图片描述

修改以上代码：

void* route_t1(void* arg)
{
    while(1)
    {
        pthread_cond_wait(&cond,&mutex);
        printf("i am thread A\n");
    }
}
void* route_t2(void* arg)
{
    while(1)
    {
        pthread_cond_signal(&cond);
        printf("i am thread B\n");
        sleep(1);
    }
}
int main()
{
    pthread_t t1,t2;
    pthread_cond_init(&cond,NULL);
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&t1,NULL,route_t1,(void**)"thread 1");
    pthread_create(&t2,NULL,route_t2,(void**)"thread 2");

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

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

}

这里写图片描述

为什么条件变量需要互斥量？

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

读写锁

读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只可以一个线程可以占用写模式的读写锁，但是多个线程可以同时占用读模式的读写锁。

读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下，他所保护的数据结构就可以被安全的修改，因为一次只有一次一个线程可以在写模式下拥有这个锁。当读写锁在读模式下，只要线程先获取了读模式下的读写锁，该锁所保护的数据几个就可以被多个获得读模式锁的线程读取。

int counter;
pthread_rwlock_t lock;
void* route_write(void* arg)
{
    int t;
    int i=*(int*)arg;
    free(arg);
    while(1)
    {
        t=counter;
        usleep(1000);
        pthread_rwlock_wrlock(&lock);
        printf("write:%d:%#x: counter=%d ++counter=%d\n",i,pthread_self(),t,++counter);
        pthread_rwlock_unlock(&lock);
        usleep(5000);
    }
}
void* route_read(void* arg)
{
    int t;
    int i=*(int *)arg;
    free(arg);
    while(1)
    {
        pthread_rwlock_rdlock(&lock);
        printf("read:%d:%#x: counter=%d\n",i,pthread_self(),counter);
        pthread_rwlock_unlock(&lock);
        usleep(900);
    }
}
int main()
{
    int i=0;
    pthread_t tid[8];
    pthread_rwlock_init(&lock,NULL);
    for(i=0;i<3;i++)
    {
        int *p=(int* )malloc(sizeof(int));
        *p=i;
        pthread_create(&tid[i],NULL,route_write,(void* )p);
    }
    for(i=0;i<5;i++)
    {
        int *p=(int* )malloc(sizeof(int));
        *p=i;
        pthread_create(&tid[i+3],NULL,route_read,(void* )p);
    }
    for(i=0;i<8;i++)
    {
        pthread_join(tid[i],NULL);
    }
    return 0;
}

这里写图片描述
可以看到结果，每次读数据都能保证正确，写数据也能保证正确。

自旋锁

自旋锁与互斥量类似，但它不是通过休眠使进程阻塞，而是在获取所之前一直处于自旋状态。自旋锁可以用于以下情况:锁被持有的时间短，而且线程并不希望在重新调度上花费太多成本。
当自旋锁用在非抢占式内核中是非常有用的：除了提供互斥机制以外，它们会阻塞中断，这样中断处理程序就不会让系统陷入死锁状态，因为它需要获取已被加锁的自旋锁。

屏障

屏障是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后从该点继续执行。我们已经看到一种屏障，pthread_join函数本身就是一种屏障，允许一个线程等待，直到另一个线程退出。但是屏障对象的概念更广，他们允许任意数量的线程等待，直到所有的线程完成处理工作，而线程不需要退出。所有线程达到屏障后可以继续工作。