APUE笔记---线程同步之互斥锁、读写锁、条件变量、POSIX信号量

最新推荐文章于 2020-07-06 11:07:05 发布
最新推荐文章于 2020-07-06 11:07:05 发布
阅读量832 收藏 2
点赞数 1
分类专栏： Linux 环境编程 文章标签： 线程 内存 存储 处理器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/men_wen/article/details/58332639
版权

APUE笔记—线程同步之互斥锁、读写锁、条件变量、POSIX信号量

1. 线程要同步的原因

  1. 共享资源,多个线程都可对共享资源操作
  2. 线程操作共享资源的先后顺序不确定
  3. 处理器对存储器的操作一般不是原子操作

下面代码演示线程对修改同一变量发生的问题，首先了解增量操作的具体步骤：
1. 从内存读入寄存器
2. 在寄存器中对变量进行增量操作
3. 把新值写会内存

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#define NLOOP   5000
int counter;

void *thr_fun(void *arg)
{
        int i, val;
        for(i = 0; i < NLOOP; i++) {
        //下面的三条代码模拟增量操作的过程
                val = counter;
                printf("%d\n", val+1);
                counter = val + 1;
        }

        return NULL;
}

int main()
{
        pthread_t tid1, tid2;

        pthread_create(&tid1, NULL, thr_fun, NULL);
        pthread_create(&tid2, NULL, thr_fun, NULL);

        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);

        return 0;
}

运行结果：

1
2
......
4999
5000

运行结果每次并不一定相同，但是counter的值并不会加到10000。所以，当多个线程对临界资源操作时，线程要同步。

2. 互斥量

基于上述原因，因此可以使用pthread的互斥接口来保护数据，确保同一时间只有一个线程访问数据。

  • 互斥量（mutex）本质上是一把锁，在访问共享资源时对互斥量进行设置（加锁），在访问完成后释放该互斥量（解锁）。

2.1 临界区（critical section）

  • 定义：临界区指的是一个访问共用资源的程序片段，而这些共用资源又无法同时被多个线程访问的特性。当有线程进入临界区段时，其他线程或是进程必须等待，有一些同步的机制必须在临界区段的进入点与离开点实现，以确保这些共用资源是被互斥获得使用。

  • 解释：在任意时刻值只允许一个线程对其共享资源进行访问，如果有多个线程试图同时访问临界区，那么在一个线程进入后，其他所有试图访问次临界区的线程将被阻塞，并一直持续到进入临界区的线程离开。临界区在被释放后，其它线程可以继续抢占，并以此达到原子方式操作共享资源的目的。

  • 临界区的选定应该尽可能的小，如果选定太大会影响程序的并行处理性能。

2.2 互斥量实例

互斥量是一个具有加锁和解锁状态的变量，所以它的数据类型用pthread_mutex_t来表示。

2.2.1互斥量的初始化和销毁函数

互斥量的初始化有两种方式。

#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//返回值：若成功，返回0，否则返回错误编号。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//将mutex设置成PTHREAD_MUTEX_INITIALIZER初始化的方式只适用于静态分配的互斥量。
2.2.2 加锁和解锁
#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

//返回值：若成功，返回0，否则返回错误编号。
  • 如果希望线程不被阻塞，pthread_mutex_trylock函数尝试对互斥量进行加锁，如果互斥量处于未加锁状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞直接返回0，否则pthread_mutex_trylock就会失败，无法锁住互斥量，返回EBUSY。

将刚才代码的thr_fun函数加入互斥量如下：

pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;//初始化

void *thr_fun(void *arg)
{
        int i, val;
        for(i = 0; i < NLOOP; i++) {

                pthread_mutex_lock(&counter_mutex);//加锁

                val = counter;
                printf("%d\n", val+1);
                counter = val + 1;

                pthread_mutex_unlock(&counter_mutex);//解锁
        }

        return NULL;
}

此时，运行结果正常，counter计数结果为10000。

2.3 临界区与互斥量的区别。

  1. 首先互斥量是一个处于加锁和解锁这两态之一的变量，而临界区是是一个访问公用资源的程序片段。在上述程序中，互斥量是counter_mutex变量，而临界区是pthread_mutex_lock函数和pthread_mutex_unlock函数之间的代码片段，在这片代码中，访问了公共资源counter。
  2. 互斥量是为在一个时刻只有一个线程对公共资源进行访问而存在的，而临界区是将多线程访问公共资源的操作变为“原子操作”，进而使多个线程实现对公共资源的串行化访问。

3.死锁

死锁： 是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

4. 读写锁

读写锁（reader-writer lock）与互斥锁类似，不过读写锁允许更高的并行性。读写锁也叫共享互斥锁（shared-exclusive lock），它的特点为：读共享，写互斥。适合于对数据结构读的次数大于写的次数。

4.1 读写锁的函数

  • 初始化和销毁函数
#include <pthread.h>

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
    const pthread_rwlockattr_t *restrict attr);
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

//返回值：若成功，返回0，否则返回错误编号。
  • 加锁解锁函数
#include <pthread.h>

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//读加锁
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//写加锁
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

//返回值：若成功，返回0，否则返回错误编号。
//trylock的两个函数，成功返回0，失败返回EBUSY。

4.2 读写锁的实例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

int counter;        //公共资源
pthread_rwlock_t rwlock;    //读写锁

void *th_rd(void *arg)
{
        while(1) {
                pthread_rwlock_rdlock(&rwlock); //读加锁
                printf("read:%d %d\n", (int)pthread_self(), counter);
                pthread_rwlock_unlock(&rwlock); //解锁
                usleep(100);    //睡眠100微秒
        }

        return NULL;
}

void *th_wt(void *arg)
{
        int t;
        while(1) {
                pthread_rwlock_wrlock(&rwlock); //写加锁
                printf("                write:%d %d\n", (int)pthread_self(), counter++);
                pthread_rwlock_unlock(&rwlock); //解锁
                usleep(1000);   //睡眠1000微秒
        }

        return NULL;
}
int main()
{
        pthread_t tid[8];
        pthread_rwlock_init(&rwlock, NULL); //初始化

        for(int i = 0; i < 3; i++) {
                pthread_create(&tid[i], NULL, th_rd, NULL);
        }   //3个读线程
        for(int i = 0; i < 5; i++) {
                pthread_create(&tid[i+3], NULL, th_wt, NULL);
        }   //5个写线程
        pthread_rwlock_destroy(&rwlock);    //释放读写锁

        for(int i = 0; i < 8; i++) {
                pthread_join(tid[i], NULL); //回收线程资源
        }

        return 0;
}

3个读线程和5个写线程，读线程每次睡眠100微秒，写线程每次睡眠1000微秒。运行结果如下：

...
read:1480128256 2058
read:1496913664 2058
read:1488520960 2058
read:1480128256 2058
                    write:1471735552 2058
                    write:1446557440 2059
read:1496913664 2060
read:1496913664 2060
read:1488520960 2060
read:1480128256 2060
                    write:1463342848 2060
                    write:1438164736 2061
                    write:1454950144 2062
read:1488520960 2063
read:1480128256 2063
read:1488520960 2063
read:1480128256 2063
...

由上述结果可知read模式下，不同的线程可以同时访问被读写锁保护的counter，在write模式下，每次有且只有一个线程对被读写锁保护的counter。

5. 条件变量

条件变量是线程可用的另一种同步机制，条件变量给多个线程提供一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

#include <pthread.h>

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);  //初始化条件变量
int pthread_cond_destroy(pthread_cond_t *cond); //释放条件变量
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);    //超时等待条件变量为真
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);  //等待条件变量为真
int pthread_cond_signal(pthread_cond_t *cond);      //唤醒至少一个等待条件的线程
int pthread_cond_broadcast(pthread_cond_t *cond);   //黄兴所有等待条件的线程

//返回值：若成功，返回0，否则返回错误编号。

5.1 条件变量实现一个生产者与一个消费者

#include <stdio.h>                                              
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

struct msg {
        struct msg *next;
        int num;
};

struct msg *head;       //队列头指针
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;  //条件变量
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;       //互斥锁

void *consumer(void *p)
{
        struct msg *mp;

        for(;;) {
                pthread_mutex_lock(&lock);  //互斥量保护条件变量
                while(head == NULL) {
                        pthread_cond_wait(&has_product, &lock);
                }
                mp = head;
                head = mp->next;
                pthread_mutex_unlock(&lock);

                printf("Consume %d\n", mp->num);
                free(mp);
                sleep(rand() % 5);
        }
}

void *producer(void *p)
{
        struct msg *mp;

        for(;;) {
                mp = malloc(sizeof(struct msg));
                mp->num = rand() % 1000 + 1;
                printf("Produce %d\n", mp->num);

                pthread_mutex_lock(&lock);
                mp->next = head;
                head = mp;      //条件变化，要加锁
                pthread_mutex_unlock(&lock);

                pthread_cond_signal(&has_product);

                sleep(rand() % 5);
        }
}


int main(void)
{
        pthread_t pid, cid;

        srand(time(NULL));

        pthread_create(&pid, NULL, producer, NULL);
        pthread_create(&cid, NULL, consumer, NULL);

        pthread_join(pid, NULL);
        pthread_join(cid, NULL);

        return 0;
}

生产者和消费者每次睡眠时间不相等，运行结果如下：

Produce 801
Produce 758
Consume 758
Produce 36
Produce 987
Consume 987
Consume 36
Consume 801
Produce 730
Produce 276
Produce 343
Produce 179

当消息队列的头指针（head）为空时，条件不成立，消费者consumer阻塞在pthread_cond_wait，当生产者生产一个消息时，此时头指针不为空，然后调用pthread_cond_signal唤醒消费者，此时head不为NULL时，消费者读数据。

5. POSIX信号量

POSIX信号量也是一种可以实现多线程同步的机制，类似于互斥量，互斥量是只有两个值，解锁和加锁，而信号量可以有多个大于零的值。

5.2 POSIX信号量的函数

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);

//返回值：成功返回0，失败返回-1并设置errno。
  • sem_init函数是初始化信号量，pshared参数如果为0，表示这个信号量是当前进程的局部信号量，否则该信号量可以在多个进程间共享。value参数指定信号量的初始值。
  • sem_destroy函数用于销毁一个信号量。
  • sem_wait函数以原子操作的方式将信号量的值减1，如果信号量为0，则sem_wait被阻塞，知道信号量为非零值。
  • sem_trywait函数是sem_wait非阻塞版本，当信号量为零，返回-1并设置errno为EAGAIN。
  • sem_post函数以原子操作的方式将信号量的值加1，当信号量值大于0，则唤醒调用sem_wait正在等待信号的线程。

5.3 POSIX信号量的函数实现生产者消费者

#include <stdio.h>                                 
#include <unistd.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>

#define NUM 5
int queue[NUM]; //环形队列
sem_t blank_number, product_number;

void *producer(void *arg)
{
        int p = 0;
        while(1) {
                sem_wait(&blank_number);    
                queue[p] = rand() % 1000 + 1;   //生产者生产1到1000随机值
                printf("produce %d\n", queue[p]);
                sem_post(&product_number);
                p = (p+1) % NUM;
                sleep(rand() % 5);
        }
}

void *consumer(void *arg)
{
        int c = 0;
        while(1) {
                sem_wait(&product_number);
                printf("consume %d\n", queue[c]);
                queue[c] = 0;   //消费者将队列值置为零
                sem_post(&blank_number);
                c = (c + 1) % NUM;
                sleep(rand() % 5);
        }
}

int main(void)
{
        pthread_t pid, cid;

        srand(time(NULL));
        sem_init(&blank_number, 0, NUM);
        sem_init(&product_number, 0, 0);

        pthread_create(&pid, NULL, producer, NULL);
        pthread_create(&cid, NULL, consumer, NULL);

        pthread_join(pid, NULL);
        pthread_join(cid, NULL);

        sem_destroy(&blank_number);
        sem_destroy(&product_number);

        return 0;
}

运行结果如下：生产者可以连续生产，但是消费者无法过度消费

produce 193
consume 193
produce 834
produce 68
consume 834
produce 646
produce 13
consume 68
produce 382
produce 322
consume 646
produce 398
produce 103
consume 13
produce 124
men_wen
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POSIX信号量
sicofield的专栏
09-02 9440
1.引言        信号量是包含一个非负整型变量，并且带有两个原子操作wait 和signal。wait 还可以被称为down、P 或lock，signal 还可以被称为up、V、unlock 或post。在Uinx的API中用的是wait和post。        如果信号量的非负整形变量S大于零，wait就将其减1，如果S 等于0，wait 就将调用线程阻塞。对于signal 操作，如
Posix多线程程序设计
03-02
2. **线程同步**：线程同步主要包括互斥锁（`pthread_mutex_t`）、条件变量（`pthread_cond_t`）、信号量（`sem_t`）等机制。互斥锁用于保护共享资源，确保同一时间只有一个线程访问；条件变量允许线程等待特定条件...
APUE读书笔记——线程互斥（互斥量、读写锁）
DrawnBreak
02-23 413
这里以文件的引用计数做例子。什么是引用计数？    即指向这个文件的链接数。 只有当引用计数为0时，才能删除该文件，否则每一次删除仅仅是i节点的引用计数减一。如果不引入锁， 那么当同时执行两次引用计数相减时，就会出现计数不准确的情况。一、简单的锁操作#include "apue.h" #include &lt;pthread.h&gt; #include &lt;stdlib.h&gt; str...
apue学习之互斥量实现线程同步
AlexanderGan的博客
07-06 222
apue学习之线程同步 一、互斥量   互斥量本质上是一把锁，线程在访问共享资源进行加锁，访问完成后进行解锁，对互斥量加锁之后，任何其他试图再对互斥量加锁的线程会被阻塞直到当前线程释放该互斥锁。如果释放互斥量时有多个线程阻塞，那么这时所有该锁上的阻塞线程都会都会变成可运行状态，第一个变成运行态的线程又对互斥量加锁。   使用互斥量时，所有的线程都要遵循相同的访问规则，互斥机制才能有效。如果某个线程在没有获得互斥量的情况下也能访问共享资源，那么这种机制就会出问题。 二、避免死锁   产生死锁的方式有两种，第一
APUE学习笔记——11 线程同步、互斥锁、自旋锁、条件变量
aidixi4007的博客
09-04 136
线程同步 同属于一个进程的不同线程是共享内存的，因而在执行过程中需要考虑数据的一致性。 假设：进程有一变量i=0，线程A执行i++，线程B执行i++，那么最终i的取值是多少呢？似乎一定是i=2；其实不然，如果没有考虑线程同步，i的取值可能是1.我们先考虑自加操作的过程：a，首先将内存中i的值copy到寄存器；b，对寄存器中i的copy进行自...
posix多线程有感--线程高级编程（互斥量属性）
weixin_34008933的博客
05-09 154
互斥量具有一些属性，通过修改这些属性可以控制锁的一些行为。缺省的互斥锁属性及其值如下：pshared：PTHREAD_PROCESS_PRIVATEtype：PTHREAD_MUTEX_DEFAULTprotocol： PTHREAD_PRIO_NONEprioceiling： –robustness：...
apue.2e.zip
10-03
2. **线程编程**：讲解线程创建、同步（互斥锁、条件变量、读写锁）、调度和取消等，帮助理解多线程环境下的程序设计。 3. **文件系统与I/O**：介绍文件系统的基本操作，如打开、关闭、读写、定位，以及低级I/O...
apue.3e.rar
最新发布
10-01
8. **多线程编程**：介绍POSIX线程（pthreads）模型，包括线程创建、同步、互斥锁和条件变量。 9. **错误处理和调试**：学习如何处理和报告错误，使用gdb进行调试，以及编写健壮的UNIX程序。 10. **进程间通信**：...
apue UNIX环境高级编程 程序包
09-03
线程创建、同步和通信（如互斥锁mutex, 条件变量cond, 读写锁rwlock等）是这一领域的关键概念。 4. **内存管理**：包括动态内存分配（malloc(), calloc(), realloc(), free()等）和内存映射（mmap()）等，以及如何...
互斥量原理及简单案例
len_yue_mo_fu的博客
06-02 1675
线程同步同步即协同步调，按预定的先后次序运行。 线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。 举例1： 银行存款 5000。柜台，折：取3000；提款机，卡：取 3000。剩余：2000 举例2： 内存中100字节，线程T1欲填入全1， 线程T2欲填入全0。但如果T1执行了50个字节失去cpu，T2执行，会将T1写过的
APUE读书笔记-15进程内部通信-08信号量
weixin_34392843的博客
04-27 74
转载于:https://blog.51cto.com/quietheart/846152
互斥锁-条件变量-信号量总结
浪子荆的博客
08-31 1945
互斥锁：mutex 条件变量：condition： pthread_cond_signal() :保证唤醒一个线程的wait pthread_cond_broadcast() ： 唤醒所有线程的wait pthread_cond_wait() ： 等待条件变量的signal or broadcast。 条件变量不保存状态信息，signal时如果没有线程在等待，则会丢失该signal，如果
APUE中文第三版11章读写锁的一个可运行的例子
liuyixxxx的博客
08-17 296
APUE中文第三版11章读写锁的一个可运行的例子我的测试环境是CentOS7(内核版本3.10），X86_64.头文件： wrlock.h`ifndef _WRLOCK_Hdefine _WRLOCK_Hinclude include include endif队列的相关操作，这一部分与书上的基本一样。 11_14.cinclude “wrlock.h”int queue_init( struc
apue学习第二十三天——消息队列、信号量与共享内存
BlitzSkies的专栏
02-10 1356
“IPC三剑客”，我们把它们放在一起讲，原因是无论在POSIX还是XSI标准中，这三种IPC类型的访问函数和描述信息有很多相似的地方。 本质上，这三种IPC又不尽相同，因为： message queue 可以和pipe、FIFO划归一类，属于message passing（消息传递）；semaphore 可以和各类锁划归一类，属于synchronization（同步）；shared m
Linux线程同步读写锁 rwlock
weixin_30663471的博客
11-25 75
转自：http://yaronspace.cn/blog/archives/1135 读写锁比mutex有更高的适用性，可以多个线程同时占用读模式的读写锁，但是只能一个线程占用写模式的读写锁。1. 当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞；2. 当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行枷锁的线程将阻...
信号量（UNIX环境高级编程笔记）
The_perfect_world的博客
04-27 547
  信号量是一个计数器，用于为多个进程提供对共享数据对象的访问。   为了获得共享资源，进程需要执行下列操作：   （1）测试控制该资源的信号量。   （2）若此信号量的值为正，则进程可以使用该资源，在这种情况下，进程会将信号量值减1，表示它使用了一个信号量的资源。   （3）否则，若此信号量的值为0，则进程进入休眠状态，直至信号量值大于0，进程被唤醒之后，将返回步骤（1）。   常用的信号量形式...
用条件变量来解决生产者消费者问题
chen_mama的专栏
08-11 3256
在上一篇文章中，我使用了匿名信号量什么是条件变量？ 我们可以设想一个场景：线程A需要某个条件成立才能继续执行，否则一直等待下去，而线程B执行过程中使线程的执行条件成立，并且唤醒A。 举个例子，在生产者消费者模型中，消费者如果看到缓冲区为空时，就等待，而生产者往缓冲区添加完数据后，唤醒消费者。 其中这个场景中，可以POSIX的条件变量来实现。 以下是条件变量所需要的函数pth
linux多线程之条件变量
BuZiShuoquoto的博客
08-02 847
转载：https://blog.csdn.net/qq_39736982/article/details/82380689 1、条件变量概述： 条件变量是用来等待线程而不是上锁的，条件变量通常和互斥锁一起使用。条件变量之所以要和互斥锁一起使用，主要是因为互斥锁的一个明显的特点就是它只有两种状态：锁定和非锁定，而条件变量可以通过允许线程阻塞和等待另一个线程发送信号来弥补互斥锁的不足，所以互斥锁和条件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值