Linux同步技术之读写锁

最新推荐文章于 2023-09-11 11:13:00 发布
置顶 最新推荐文章于 2023-09-11 11:13:00 发布
阅读量1.6k 收藏 1
点赞数 1
分类专栏： 网络编程 文章标签： 读写锁 同步 条件变量 互斥量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_33736971/article/details/51510891
版权

互斥锁试图将想进入临界区的所有线程都阻塞住，但是有时候该临界区会涉及由这些线程共享的一个或多个数据的访问或更新，这时候我们就需要用到读写锁。

系统读写锁的分配规则：
（1）只要有没有线程持有给定的读写锁用于写，那么任意数量的线程可以持有该读写锁用于读。（系统规定写锁优先，但是可以更改为读锁优先）
（2）仅当没有线程持有某个读写锁用于读或用于写时，才能分配该读写锁用于写。

读写锁用于读称为共享锁，读写锁用于写称为独占锁。

读写锁的获取与释放：
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
该函数获取一个读出锁，如果对应的读写锁已由某个写入者持有，那就阻塞该调用线程。参数rwlock是读写锁变量，类型为pthread_rwlock_t。

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
该函数尝试获取一个读出锁或写入锁，但是如果该所不能马上获得，就返回一个EBUSY错误，但是不阻塞调用线程。

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
该函数获取一个写入锁，如果对应的读写锁已由另一个写入者持有，或者由一个或多个读出者持有，就阻塞该调用线程。

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
该函数释放一个读出锁或写入锁。

如果一个读写锁是静态分配的，即就是static pthread_rwlock_t rwlock，则其就初始化为PTHREAD_RWLOCK_INITIALIZER。

如果读写锁是动态分配的，那就需要调用如下函数进行初始化和释放！
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
读写锁的动态销毁函数。

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);
读写锁的动态初始化函数。第二个参数是属性，可以设置为NULL即就是使用默认属性，若不希望使用默认属性则可以通过调用系统的属性的初始化和销毁函数来设置和销毁属性。

以下是一个使用读写锁的实现读优先的例子：

//头文件
#pragma once

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


typedef struct 
{
    pthread_mutex_t rw_mutex;
    pthread_cond_t  rw_condreaders;
    pthread_cond_t  rw_condwriters;
    int rw_magic;
    int rw_nwaitreaders;
    int rw_nwaitwriters;
    int rw_refcount;
}my_pthread_rwlock_t;

#define RW_MAGIC 0x19283746

#define MY_PTHREAD_RWLOCK_INITIALIZER {PTHREAD_MUTEX_INITIALIZER,\
                                   PTHREAD_COND_INITIALIZER,\
                                   PTHREAD_COND_INITIALIZER,\
                                   RW_MAGIC, 0, 0, 0}

typedef int my_pthread_rwlockattr_t;


int my_pthread_rwlock_init(my_pthread_rwlock_t *, my_pthread_rwlockattr_t *);
int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *);
int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *);
int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *);
int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *);
int my_pthread_rwlock_unlock(my_pthread_rwlock_t *);
int my_pthread_rwlock_destroy(my_pthread_rwlock_t *);

void clean_up(void *arg);
//读写锁的初始化和销毁函数
#include "pthread_rwlock.h"

//读写锁的初始化
int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr)
{
    if(attr != NULL){    //属性只有设置了NULL，若不为NULL则返回错误
        return(EINVAL);
    }

    int result;
    if((result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0){   //互斥锁的初始化，成功返回0，失败返回非0
        return result;
    }
    if((result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0){  //初始化读条件变量，成功返回0，失败时销毁互斥量
        pthread_mutex_destroy(&rw->rw_mutex);
    }

    if((result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0){   //初始化写条件变量，成功返回0，失败时销毁互斥量和读条件变量
        pthread_cond_destroy(&rw->rw_condreaders);
        pthread_mutex_destroy(&rw->rw_mutex);
    }

    rw->rw_nwaitreaders = 0;   //初始化等待读锁的线程数
    rw->rw_nwaitwriters = 0;   //初始化等待写锁的线程数
    rw->rw_refcount = 0;       //初始化持有锁的线程数
    rw->rw_magic = RW_MAGIC;   //初始化魔法数（魔法数可有可无，该数只是用来作判断）


    return 0;
}

//读写锁的销毁
int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw)
{
    if(rw->rw_magic != RW_MAGIC){
        return (EINVAL);
    }

    if(rw->rw_refcount != 0 || rw->rw_nwaitreaders != 0 || rw->rw_nwaitwriters != 0){   //若持有锁的线程数不为0，或等待读锁的线程数不为0，或等待写锁的线程数不为0，就返回BUSY;
        return (EBUSY);
    }

    pthread_mutex_destroy(&rw->rw_mutex);   //销毁互斥锁
    pthread_cond_destroy(&rw->rw_condreaders);  //销毁读条件变量
    pthread_cond_destroy(&rw->rw_condwriters);  //销毁写条件变量

    rw->rw_magic = 0;   //魔法数赋0
    return 0;
}


//系统默认的写锁优先实现
int my_pthread_rint my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return (EINVAL);
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){    //mutex_lock 保护临界区域
        return result;
    }

    while(rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0){   //（写优先）有线程持有锁，或是写等待的线程数大于0，即有写线程在等待锁时，读线程数增加
        rw->rw_nwaitreaders++;
        result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);    //等待读的线程被阻塞，当某时收到信号时，等待读的线程被唤醒， 等待读的线程数减少
        rw->rw_nwaitreaders--;

        if(result != 0){
            break;
        }
    } 

    if(result == 0){
        rw->rw_refcount++;     //持有锁的读线程数增加，读锁是共享锁，同时可有多个线程持有读锁
    }

    pthread_mutex_unlock(&rw->rw_mutex);   

    return result;
}


int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){
        return result;
    }

    while(rw->rw_refcount != 0){  //说明有线程正在持有锁，所以等待加写锁的线程数增加
        rw->rw_nwaitwriters++;
        result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
        rw->rw_nwaitwriters--;

        if(result != 0){
            break;
        }
    }

    if(result == 0){   //正常退出循环或者未进入循环
        rw->rw_refcount = -1;  //有一个线程持有写锁，写锁是独占锁，每次只能有一个线程持有写锁
    }

    pthread_mutex_unlock(&rw->rw_mutex);
    return result;
}
#endif



int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
{
    int result;
    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){
        return result;
    }

    if(rw->rw_refcount > 0){   //说明有线程持有读锁，解锁是持有读锁的线程数减少
        rw->rw_refcount--;
    }else if(rw->rw_refcount == -1){   //说明有一个线程持有写锁，解锁完成后持有锁的线程数为0，因为每次只会有一个线程持有写锁
        rw->rw_refcount = 0;
    }else{    //没有线程持有锁，解锁失败
        printf("unlock error.\n");
    }


    //处理等待锁的线程
    if(rw->rw_nwaitwriters > 0){   //先处理等待写的线程，因为是写锁优先
        if(rw->rw_refcount == 0){   //若当前没有线程持有锁，则给等待写锁的线程发送一个信号，单播信号，每次只能有一个线程持有写锁
            result = pthread_cond_signal(&rw->rw_condwriters);
        }
    }else if(rw->rw_nwaitreaders > 0){   //再处理等待读的线程，
        result = pthread_cond_broadcast(&rw->rw_condreaders);  //读锁是共享锁，所以以广播的方式给等待读的线程发送信号，唤醒所有等待读的线程
    }

    pthread_mutex_unlock(&rw->rw_mutex);

    return result;
}wlock_rdlock(my_pthread_rwlock_t *rw)
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return (EINVAL);
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){    //mutex_lock 保护临界区域
        return result;
    }

    while(rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0){   //（写优先）有线程持有锁，或是写等待的线程数大于0，即有写线程在等待锁时，读线程数增加
        rw->rw_nwaitreaders++;
        result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);    //等待读的线程被阻塞，当某时收到信号时，等待读的线程被唤醒， 等待读的线程数减少
        rw->rw_nwaitreaders--;

        if(result != 0){
            break;
        }
    } 

    if(result == 0){
        rw->rw_refcount++;     //持有锁的读线程数增加，读锁是共享锁，同时可有多个线程持有读锁
    }

    pthread_mutex_unlock(&rw->rw_mutex);   

    return result;
}


int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){
        return result;
    }

    while(rw->rw_refcount != 0){  //说明有线程正在持有锁，所以等待加写锁的线程数增加
        rw->rw_nwaitwriters++;
        result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
        rw->rw_nwaitwriters--;

        if(result != 0){
            break;
        }
    }

    if(result == 0){   //正常退出循环或者未进入循环
        rw->rw_refcount = -1;  //有一个线程持有写锁，写锁是独占锁，每次只能有一个线程持有写锁
    }

    pthread_mutex_unlock(&rw->rw_mutex);
    return result;
}
#endif

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
{
    int result;
    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){
        return result;
    }

    if(rw->rw_refcount > 0){   //说明有线程持有读锁，解锁是持有读锁的线程数减少
        rw->rw_refcount--;
    }else if(rw->rw_refcount == -1){   //说明有一个线程持有写锁，解锁完成后持有锁的线程数为0，因为每次只会有一个线程持有写锁
        rw->rw_refcount = 0;
    }else{    //没有线程持有锁，解锁失败
        printf("unlock error.\n");
    }


    //处理等待锁的线程
    if(rw->rw_nwaitwriters > 0){   //先处理等待写的线程，因为是写锁优先
        if(rw->rw_refcount == 0){   //若当前没有线程持有锁，则给等待写锁的线程发送一个信号，单播信号，每次只能有一个线程持有写锁
            result = pthread_cond_signal(&rw->rw_condwriters);
        }
    }else if(rw->rw_nwaitreaders > 0){   //再处理等待读的线程，
        result = pthread_cond_broadcast(&rw->rw_condreaders);  //读锁是共享锁，所以以广播的方式给等待读的线程发送信号，唤醒所有等待读的线程
    }

    pthread_mutex_unlock(&rw->rw_mutex);

    return result;
}
//自己设置的读锁优先的实现
int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)  //解锁过程
{
    int result;
    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){   //互斥锁加锁与解锁之间形成临界区
        return result;
    }

    if(rw->rw_refcount > 0){  //说明持有读锁的线程数 > 0
        rw->rw_refcount--;   //将读锁的数量减一
    }else if(rw->rw_refcount == -1){  //说明有一个线程持有读锁
        rw->rw_refcount = 0;  //解锁之后持有锁的线程数为0
    }else{  //没有线程持有锁，解锁失败
        printf("unlock error.\n");
    }
    //处理等待加读写锁的线程
    if(rw->rw_nwaitreaders > 0){   //若等待加读锁的线程数>0,就广播发送信号（读锁是共享锁即每次可有多个线程加上读锁），使所有等待加读锁的线程全部加锁
        result = pthread_cond_broadcast(&rw->rw_condreaders);
    }else if(rw->rw_nwaitwriters > 0){   //若等到加写锁的线程>0，并且持有锁的线程的个数为0，就单播发送信号，使得等待加写锁的线程中的一个线程被唤醒
        if(rw->rw_refcount == 0){
            result = pthread_cond_signal(&rw->rw_condwriters);
        }
    }

    pthread_mutex_unlock(&rw->rw_mutex);  //解锁互斥量

    return result;
}

int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)   //读锁实现
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return (EINVAL);
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){  //加锁互斥量与解锁互斥量形成临界区
        return result;
    }
    //读锁优先的实现
    while(rw->rw_refcount != 0){    //说明有线程持有锁
        rw->rw_nwaitreaders++;   //所以等待加读锁的线程数增加
        pthread_cleanup_push(clean_up, NULL);
        result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);  //等待加读锁的线程被阻塞，当某时收到加读锁信号的时候，等待加读锁的线程数减少
        pthread_cleanup_pop(0);
        rw->rw_nwaitreaders--;

        if(result != 0){
            break;
        }
    }


    if(result == 0){  //正常退出循环或者未进入while循环
        rw->rw_refcount++;    //所有等待读锁的线程加锁（读锁是共享锁，同时可有多个线程加锁成功）
    }

    pthread_mutex_unlock(&rw->rw_mutex);   //解锁互斥量                  
    return result;
}

//读锁优先下的写锁实现
int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
{
    int result;

    if(rw->rw_magic != RW_MAGIC){
        return EINVAL;
    }

    if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0){
        return result;
    }

    while(rw->rw_refcount > 0 || rw->rw_nwaitreaders > 0){   //当持有锁的线程数>0并且等待加读锁的线程数>0时，等待写锁的线程数加一
        rw->rw_nwaitwriters++;
        pthread_cleanup_push(clean_up, NULL);
        result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);  //等待加写锁的线程被阻塞，当某时收到可以加写锁的信号的时候，等待加写锁的一个线程被唤醒
        pthread_cleanup_pop(0);
        rw->rw_nwaitwriters--;

        if(result != 0){
            break;
        }
    } 

    if(result == 0){   //while循环正常退出或者未进入循环
        rw->rw_refcount = -1;   //一个线程持有写锁（写锁是独占锁，同一时刻只有一个线程持有写锁）
    }

    pthread_mutex_unlock(&rw->rw_mutex);   //解锁互斥量
    return result;
}
lm_123_456
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程（三）读写锁详解
liuming
05-25 2246
一、读写锁 从字面意思可以看出读写锁就是一种具有两种模式的锁（本质上是一把锁），分别为读模式和写模式，以此读写锁可以分为三种状态：读模式下的加锁状态、写模式下的加锁状态、不加锁状态；读写锁的适用于大量读小量写的场景，在大量读的环境中效率要远远高于互斥锁，他支持读模式与读模式并行，这样就调高了效率，当读线程抢占了锁之后，仍然支持其他的读线程去获取锁资源，这样既保持了原子性又提高了效率，但是在读与写同时发生的时候，它的效率与互斥锁是差不多的，并且写锁的优先级是高于读锁的；可以将它的特性简单的概括为：写独占读共
实验六Linux内核同步编程技术
09-23
**实验六：Linux内核同步编程技术** 在Linux操作系统中，进程通信是多任务环境中的核心组成部分，它允许不同进程间交换数据，实现协同工作。本实验主要关注三种通信方式：信号、管道和内存共享，这些都是Linux内核...
一文详解读写锁
热门推荐
磊哥聊Java
05-11 1万+
作者 | 磊哥来源 | Java面试真题解析（ID：aimianshi666）转载请联系授权（微信ID：GG_Stone）读写锁（Readers-Writer Lock）顾名思义是一把锁分为两部分：读锁和写锁，其中读锁允许多个线程同时获得，因为读操作本身是线程安全的，而写锁则是互斥锁，不允许多个线程同时获得写锁，并且写操作和读操作也是互斥的。总结来说，读写锁的特点是：读读...
linux读写锁
m0_57678852的博客
11-20 2173
3） 读写不能同时进行，写的优先级高：例如，线程A加读锁成功，又来了B线程加写锁阻塞，又来了C线程加读锁阻塞。4）线程 A 加读锁成功，然后线程 B 请求写锁，然后线程 C 请求读锁 ：B 写阻塞，C 读阻塞；5）线程 A 加读写成功，然后线程 B 请求读锁，然后线程 C 请求写锁 ：B 读阻塞，C 写阻塞；2）写独占-串行处理：例如，线程 A 加写锁成功，有来个 3 个线程，作读操作，3 个线程阻塞。1）读共享-并行处理：例如，线程 A 加读锁成功，有来个 3 个线程，作读操作，也可加锁成功。
读写锁ReentrantReadWriteLock详解
CodePanda@GPF的博客
04-10 3361
读写锁、ReentrantReadWriteLock
七、读写锁
博观而约取
12-19 425
01. 读写锁概述 当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。 在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应...
Linux内核同步编程技术.doc
03-29
Linux内核同步编程技术是操作系统领域的一个重要主题，它涉及到多进程或线程之间的协调与通信，确保在并发环境中正确地访问共享资源。本实验主要探讨了四种不同的进程间通信（IPC）机制：信号、管道、命名管道（FIFO...
Linux内核的同步机制
11-10
Linux内核的同步机制在设计和实现中至关重要，因为它们确保了在多任务和多线程环境下，对共享数据的访问是安全和有序的。在Linux内核中，多种同步机制协同工作，以应对不同场景下的同步需求。下面将详细讨论其中的...
嵌入式Linux中的进程同步无竞争态读写
08-04
在嵌入式Linux环境中，进程同步无竞争态读写是一个重要的概念，特别是在多进程并发执行时，确保数据的一致性和完整性至关重要。进程的状态通常包括运行、阻塞、就绪和终止，而在并发环境下，如果不加以控制，多个...
嵌入式系统/ARM技术中的Linux内核同步机制的自旋锁原理
11-07
自旋锁是Linux内核中一种重要的同步机制，特别是在多处理器（SMP）环境中，用于保护共享资源免受并发访问。...因此，合理地使用自旋锁，结合其他的同步机制，如信号量、读写锁等，可以构建更加健壮和高效的嵌入式系统。
linux文件读写锁实例C代码
04-08
linux文件读写锁一个例子，已经通过测试，使用非常方便
linux下实现高性能读写锁（read/write lock）
07-07
在linux下按照windows的slim read/write lock算法实现的读写锁源码。
【Linux操作系统】Linux系统编程中的读写锁
Goforyouqp的博客
08-28 4561
读写锁（Read-Write Lock）是一种特殊的锁机制，用于在多线程环境下对共享资源进行读写操作。与互斥锁不同，读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。读写锁可以提高并发性能，适用于读操作比写操作频繁的场景。在Linux系统编程中，读写锁的相关函数也是通过pthread库提供的。函数初始化了一个读写锁，然后创建了两个读线程和一个写线程。函数获取写锁，然后进行相应的读写操作。函数获取读锁，写线程通过。在上述代码中，我们使用。
linux-读写锁(rwlock)
最新发布
jiu_yue_ya的博客
09-11 468
动态初始化是在堆中申请空间，需要释放，而静态初始化是在静态存储区中创建，不。在 linux 中，通过 pthread_rwlock_t 结构来表示一个读写锁。1.如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作；3 如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁；4.如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。读写锁与互斥量类似，不过读写锁允许更改的并行性，释放读写锁(pthread_rwlock_destroy)读写锁的属性，为 NULL 表示默认属性。
读写锁简介
justlpf的专栏
06-05 268
为什么读写要互斥，读的时候不能写，写的时候不能读？举个例子，用户A正在读的时候，用户B对数据进行了写操作，就会出现A读到的数据不准确。A在写的时候，B去读，则读到的数据也是不准确的。所以读和写要互斥。
锁系列二之读写锁
勇心在馨
01-19 1097
从数据操作的类型划分 对于 InnoDB 引擎来说，读锁和写锁可以加在表上，也可以加在行上。 一、读锁 也称为 共享锁 、英文用 S 表示。针对同一份数据，多个事务的读操作可以同时进行而不会互相影响，相互不阻塞的。 二、写锁 也称为 排他锁 、英文用 X 表示。当前写操作没有完成前，它会阻断其他写锁和读锁。这样就能确保在给定的时间里，只有一个事务能执行写入，并防止其他用户读取正在写入的同一资源。 1、锁定读 在采用加锁方式解决脏读，不可重复读，幻读这些问题的时候，读取一条记录时需要获取该记..
ReentrantReadWriteLock读写锁
m0_56054652的博客
11-04 1990
一、前言 ReentrantReadWriteLock中包含三种锁：读写锁、可重入锁、公平/非公平锁 1、读写锁 2、可重入锁： 又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。 对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。 对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。 syn...
深度解析：读写锁原理
qq_37685457的博客
05-05 8577
对于多个线程共享同一个资源的时候，多个线程同时对共享资源做读操作是不会发生线程安全性问题的，但是一旦有一个线程对共享数据做写操作其他的线程再来读写共享资源的话，就会发生数据安全性问题，所以出现了读写锁ReentrantReadWriteLock。读写锁允许多个线程同时获取读锁，但有一个线程获取写锁之后其他线程都会进入等待队列进行等待。 读写锁的写锁是一把独占锁，它与ReentrantLock的原...
读写锁详解
weixin_30564901的博客
10-10 376
1. 综述 　　在一些程序中存在读者写者问题，也就是说，对某些资源的访问会存在两种可能的情况，一种是访问必须是排它行的，就是独占的意思，这称作写操作；另一种情况就是访问方式可以是共享的，就是说可以有多个线程同时去访问某个资源，这种就称作读操作。这个问题模型是从对文件的读写操作中引申出来的。 读写锁比起mutex具有更高的适用性，具有更高的并行性，可以有多个线程同时占用读模式的读写锁...
LINUX C++ 高并发读写串口
05-12
在Linux下，可以使用C++中的文件操作和多线程技术实现高并发读写串口。具体实现步骤如下： 1. 打开串口设备文件 使用C++中的文件操作函数`open()`打开串口设备文件，获取文件描述符。例如： ```c++ int fd = open...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值