Linux系统编程系列之互斥锁和读写锁

一、什么是互斥锁和读写锁

        互斥锁是一种并发机制,用于控制多个线程对共享资源的访问。

        读写锁是一种并发机制,用于控制多个线程对共享资源的访问。

二、特性

        1、互斥锁

        当一个线程获得了互斥锁并进入临界区(对共享资源进行访问)时,其他线程将被阻塞,直到该线程释放互斥锁。这可以确保同时只有一个线程能够访问共享资源,避免多个线程同时修改共享资源导致数据不一致或其他问题。

        2、读写锁

        读写锁允许多个线程同时读取共享资源,但是只允许一个线程进行写操作。在读取共享资源时,多个线程可以同时获得读锁,不会相互阻塞,从而提高了并发性能。而在写操作时,只有一个线程可以获得写锁,其他线程将被阻塞,以避免同时修改导致数据不一致或其他问题。        

        使用读写锁可以有效地提高系统的并发性能和吞吐量,访问效率比互斥锁高。

三、使用场景

        1、互斥锁

                (1)、 线程共享同一个全局变量或者静态变量时,需要使用互斥锁来保证数据的一致性和正确性。
                (2)、 多个线程访问共享资源时,需要使用互斥锁来保证同一时间只有一个线程能够访问共享资源。
                (3)、 线程需要保证一段代码的原子性操作时,需要使用互斥锁来对这段代码进行加锁保护。
                (4)、 多线程并发执行时,需要使用互斥锁来保证线程间执行的顺序和正确性。

                总之,互斥锁主要用于控制多个线程对共享资源的访问,确保同一时刻只有一个线程能够访问共享资源。

        2、读写锁

                (1)、读多写少的情况,读写锁可以提高并发读的性能。读写锁允许多个线程同时读取共享资源,但只允许一个线程进行写操作。
                (2)、对于频繁的读取共享资源和不频繁的写入共享资源的场景,使用读写锁可以避免由于写操作的串行化导致的性能瓶颈。
                (3)、适用于需要有一定实时性的场景,读写锁中的读操作是共享的,可以在不阻塞其他线程执行的情况下快速地读取数据,提高程序的响应速度。

                总之,读写锁适用于读多写少的场景,可以提高并发读的性能,避免由于写操作的串行化导致的性能瓶颈,并且具有一定的实时性。

四、同步与互斥

        互斥可以简单理解为控制两个进度使之互相排斥,不同同时运行。

        同步可以简单理解为控制两个进度使之有先有后,次序可控。

Linux系统编程系列之互斥锁和读写锁_第1张图片

五、相关的函数API接口

        1、互斥锁

                (1)、定义

// 互斥锁是一个特殊的变量
// 声明一个互斥锁变量m
pthread_mutext_t m;

                (2)、初始化和销毁

                未经初始化的互斥锁是无法使用的,初始化互斥锁有两种办法:


// 静态初始化
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

// 动态初始化
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                       const pthread_mutexattr_t *restrict attr);
// 接口说明
        返回值:一直都是0
        参数mutex:互斥锁
        参数attr:互斥锁属性(一般置为NULL)

// 销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

// 接口说明
       返回值:成功返回0,失败返回错误码
       参数mutex:互斥锁


由于静态初始化互斥锁不涉及动态内存,因此无需显式释放互斥锁资源,互斥锁会伴随程序一直存在,直到程序退出为止。而动态初始化指使用 pthread_mutex_init()给互斥锁分配动态内存并赋予初始值,因此这种情况下的互斥锁需要在用完之后显式地进行释放资源。

                (3)、加锁

// 阻塞上锁
int pthread_mutex_lock(pthread_mutex_t *mutex);

// 接口说明
        返回值:成功返回0,失败返回错误码
        参数mutex:互斥锁


// 非阻塞上锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);

// 接口说明
        返回值:成功返回0,失败返回错误码
        参数mutex:互斥锁

                (4)、解锁

// 解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

// 接口说明
        返回值:成功返回0,失败返回错误码
        参数mutex:互斥锁

              (5)、锁属性

                当某一个线程所执行的功能有可能发生递归时,需要注意互斥锁的属性问题,需要对有可能被同一个线程重复加锁的锁资源设置为允许递归(重复)上锁。但是需要注意的是,同一个线程对同一锁资源上了多次锁,就需要解锁多少次,否则其他线程将永远无法获得该锁资源(死锁)。

// 初始化线程互斥锁属性
int pthread_mutexattr_init(pthread_mutexattr_t *attr);

// 销毁线程互斥锁属性
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);


// 设置线程互斥锁属性
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);

// 设置锁类型为递归锁
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

          2、读写锁

                (1)、定义

// 读写锁是一种特殊的变量
// 声明一个读写锁变量rw
pthread_rwlock_t rw;

                (2)、初始化和销毁

                跟互斥锁的初始化和销毁差不多

// 静态初始化
pthread_rwlock_t rw = PTHREAD_RWLOCK_INITIALIZER;

// 动态初始化
 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t *restrict attr);

// 接口说明
        返回值:成功返回0,失败返回错误码
        参数rwlock:读写锁
        参数attr:读写锁属性

// 销毁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

// 接口说明
        返回值:成功返回0,失败返回错误码
        参数rwlock:读写锁

                (3)、加锁

// 阻塞加读锁
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);

                (4)、解锁

// 解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

                (5)、锁属性

// 初始化读写锁属性
int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);


// 销毁读写锁属性
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);


// 设置读写锁属性
int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr,
                                  int pref);


// 获取读写锁属性
int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *attr,
                                  int *pref);

// 接口说明
        参数pref有以下几种:
        (1)、PTHREAD_RWLOCK_PREFER_READER_NP,偏向读取(读锁优先)
        (2)、PTHREAD_RWLOCK_PREFER_WRITER_NP,偏向写入(写锁优先)
        (3)、PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,偏向写入非递归
        (4)、PTHREAD_RWLOCK_PREFER_DEFAULT_NP,默认


操作步骤:
(1)、初始化锁属性
(2)、设置锁属性
(3)、使用动态初始化的方式初始化锁资源
(4)、销毁锁属性

                偏向写入:是指读写锁的属性设置为优先考虑写入操作,即在有写锁请求时,读锁请求将被阻塞,直到写锁释放。

                偏向读取:是指读锁操作优先处理,如果有读锁请求时,则写锁请求将被阻塞。

                写入非递归:写入操作不支持递归调用,即同一个线程不能在持有写入锁的情况下再次请求写入锁。如果在持有写入锁的情况下再次请求写入锁,则会导致死锁。

                写入递归:写入操作支持递归调用,即同一个线程可以在持有写入锁的情况下再次请求写入锁。如果使用写入递归模式,需要注意避免出现死锁的情况。

六、案例

        用互斥锁来实现两个线程的数据同步,一个负责发送,一个负责接收

// 互斥锁的案例

#include 
#include 
#include 
#include 
#include 

char data[100];

pthread_mutex_t data_mutex; // 定义互斥锁变量
pthread_once_t data_mutex_once_init;    // 函数单例初始化变量
pthread_once_t data_mutex_once_destroy;    // 函数单例销毁变量

// 初始化互斥锁data_mutex
void data_mutex_init(void)
{
    pthread_mutex_init(&data_mutex, NULL);
}

// 销毁互斥锁data_mutex
void data_mutex_destroy(void)
{
    pthread_mutex_destroy(&data_mutex);
}

// 线程1的例程函数,用来接收数据
void *recv_routine(void *arg)
{
    printf("I am recv_routine, my tid = %ld\n", pthread_self());

    // 设置线程分离 
    pthread_detach(pthread_self()); 

    // 函数单例,本程序只会执行data_mutex_init()一次
    pthread_once(&data_mutex_once_init, data_mutex_init);

    sleep(1);   // 先睡眠1s,保证让线程2先执行
    while(1)
    {
        pthread_mutex_lock(&data_mutex);    // 阻塞等待有数据才可以申请成功,用来同步
        printf("pthread1 read data: %s\n", data);
        memset(data, 0, sizeof(data));
        
    }

    // 函数单例,本程序只会执行data_mutex_init()一次
    pthread_once(&data_mutex_once_destroy, data_mutex_destroy);
}

// 线程2的例程函数,用来发送数据
void *send_routine(void *arg)
{
    printf("I am send_routine, my tid = %ld\n", pthread_self());

    // 函数单例,本程序只会执行data_mutex_init()一次
    pthread_once(&data_mutex_once_init, data_mutex_init);

    // 先申请锁,防止线程1读取空数据,为同步做准备
    pthread_mutex_lock(&data_mutex);

    while(1)
    {
        printf("please input data:\n");
        fgets(data, 100, stdin);
        printf("pthread2 send data\n");
        pthread_mutex_unlock(&data_mutex);  // 解锁,相当于给线程1发送信号
    }

    // 函数单例,本程序只会执行data_mutex_init()一次
    pthread_once(&data_mutex_once_destroy, data_mutex_destroy);
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;

    // 创建线程1,用来接收数据
    errno = pthread_create(&tid1, NULL, recv_routine, NULL);
    if(errno == 0)
    {
        printf("pthread create recv_routine success, tid = %ld\n", tid1);
    }
    else
    {
        perror("pthread create recv_routine fail\n");
    }

    // 1、定义线程属性变量
    pthread_attr_t attr2;

    // 2、初始化线程属性变量
    pthread_attr_init(&attr2);

    // 3、设置分离属性
    pthread_attr_setdetachstate(&attr2, PTHREAD_CREATE_DETACHED);

    // 4、创建线程2,用来发送数据,线程拥有分离属性
    errno = pthread_create(&tid2, &attr2, send_routine, NULL);
    if(errno == 0)
    {
        printf("pthread create send_routine success, tid = %ld\n", tid2);
    }
    else
    {
        perror("pthread create send_routine fail\n");
    }

    // 5、销毁属性变量
    pthread_attr_destroy(&attr2);

    // 一定要加这个,否则主函数直接退出,相当于进程退出,所有线程也退出
    // 或者加上while(1)等让主函数不退出
    pthread_exit(0);
    
    return 0;
}

Linux系统编程系列之互斥锁和读写锁_第2张图片

        用读写锁来实现对一个整型数据的操作和访问,一条线程使数据自增,另外一条线程判断该数据的奇偶性,并设置写锁优先。

 

// 读写锁的案例

#include 
#include 
#include 
#include 
#include 

int data = 100; // 共享变量

pthread_rwlock_t data_rwlock; // 定义互斥锁变量
pthread_once_t data_rwlock_once_init;    // 函数单例初始化变量
pthread_once_t data_rwlock_once_destroy;    // 函数单例销毁变量

// 初始化互斥锁data_rwlock
void data_rwlock_init(void)
{
    pthread_rwlockattr_t data_rwlock_attr;
    // 设置锁属性为写锁优先
    // 1、初始化读写锁属性
    pthread_rwlockattr_init(&data_rwlock_attr);

    // 2、设置读写锁属性为写锁优先
    pthread_rwlockattr_setkind_np(&data_rwlock_attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);

    // 3、动态初始化锁资源,此时读写锁是写锁优先的
    pthread_rwlock_init(&data_rwlock, NULL);

    // 4、销毁读写锁属性
    pthread_rwlockattr_destroy(&data_rwlock_attr);
}

// 销毁互斥锁data_rwlock
void data_rwlock_destroy(void)
{
    pthread_rwlock_destroy(&data_rwlock);
}

// 线程1的例程函数,用来接收数据
void *recv_routine(void *arg)
{
    printf("I am recv_routine, my tid = %ld\n", pthread_self());

    // 设置线程分离 
    pthread_detach(pthread_self()); 

    // 函数单例,本程序只会执行data_rwlock_init()一次
    pthread_once(&data_rwlock_once_init, data_rwlock_init);

    while(1)
    {
        // 加上读锁
        pthread_rwlock_rdlock(&data_rwlock);    
        if(data % 2)
        {
            printf("%d 是奇数\n", data);
        }
        else
        {
            printf("%d 是偶数\n", data);
        }
        // 解锁
        pthread_rwlock_unlock(&data_rwlock);
    }

    // 函数单例,本程序只会执行data_rwlock_init()一次
    pthread_once(&data_rwlock_once_destroy, data_rwlock_destroy);
}

// 线程2的例程函数,用来发送数据
void *send_routine(void *arg)
{
    printf("I am send_routine, my tid = %ld\n", pthread_self());

    // 函数单例,本程序只会执行data_rwlock_init()一次
    pthread_once(&data_rwlock_once_init, data_rwlock_init);

    while(1)
    {
        // 加上写锁
        pthread_rwlock_wrlock(&data_rwlock);

        data++;

        // 解锁
        pthread_rwlock_unlock(&data_rwlock);
    }

    // 函数单例,本程序只会执行data_rwlock_init()一次
    pthread_once(&data_rwlock_once_destroy, data_rwlock_destroy);
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;

    // 创建线程1,用来接收数据
    errno = pthread_create(&tid1, NULL, recv_routine, NULL);
    if(errno == 0)
    {
        printf("pthread create recv_routine success, tid = %ld\n", tid1);
    }
    else
    {
        perror("pthread create recv_routine fail\n");
    }

    // 1、定义线程属性变量
    pthread_attr_t attr2;

    // 2、初始化线程属性变量
    pthread_attr_init(&attr2);

    // 3、设置分离属性
    pthread_attr_setdetachstate(&attr2, PTHREAD_CREATE_DETACHED);

    // 4、创建线程2,用来发送数据,线程拥有分离属性
    errno = pthread_create(&tid2, &attr2, send_routine, NULL);
    if(errno == 0)
    {
        printf("pthread create send_routine success, tid = %ld\n", tid2);
    }
    else
    {
        perror("pthread create send_routine fail\n");
    }

    // 5、销毁属性变量
    pthread_attr_destroy(&attr2);

    // 一定要加这个,否则主函数直接退出,相当于进程退出,所有线程也退出
    // 或者加上while(1)等让主函数不退出
    pthread_exit(0);
    
    return 0;
}

Linux系统编程系列之互斥锁和读写锁_第3张图片

七、总结

        互斥锁和读写锁都是一种并发机制,用于控制多个线程对共享资源的访问。互斥锁主要用于控制多个线程对共享资源的访问,确保同一时刻只有一个线程能够访问共享资源,而读写锁适用于读多写少的场景,可以提高并发读的性能。 读写锁的属性设置需要遵循一定的步骤。

你可能感兴趣的:(Linux,C语言程序设计,c语言,linux)