Linux线程(2)--线程同步(1)--互斥锁、读写锁

最新推荐文章于 2024-10-04 21:58:42 发布
最新推荐文章于 2024-10-04 21:58:42 发布
阅读量189 收藏
点赞数
分类专栏： # Linux线程 文章标签： 多线程 linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_insting/article/details/115339476
版权

线程同步

1 线程同步的概念

线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。



2 线程不同步导致的现象

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

void *MyThread(void *argv)
{
    while (1) 
    {   
        printf("HELLO ");
        usleep(rand()%3);
        printf("WORLD\n");
        usleep(rand()%3);
    }   
}

int main()
{
    srand(time(NULL));
    pthread_t threadID;

    int ret = pthread_create(&threadID, NULL, MyThread, NULL);
    if (0 != ret)
    {   
        printf("pthread_create faild:%s\n", strerror(ret));
        exit(1);
    }   

    while (1) 
    {   
        printf("hello ");
        usleep(rand()%3);
        printf("world\n");
        usleep(rand()%3);
    }   
    return 0;
}

在这里插入图片描述
运行上面的代码，得到的结果并不是我们想象中一行小写的"hello world"，再一行大写的"HELLO WORLD"。

这就是线程不同步导致的，两个线程都对全局变量STDOUT(即屏幕)输出，产生了这种现象叫做“与时间有关的错误” (time related)。造成了数据混乱。

为了避免这种数据混乱，线程需要同步。

“同步”的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。

因此， 所有“多个控制流，共同操作一个共享资源” 的情况，都需要同步。

数据混乱原因：

  1. 资源共享（独享资源则不会）
  2. 调度随机（意味着数据访问会出现竞争）
  3. 线程间缺乏必要的同步机制。

以上 3 点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。



3 互斥锁(mutex)

3.1 互斥锁的概念

Linux 中提供一把互斥锁 mutex（也称之为互斥量）。

每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。

资源还是共享的，线程间也还是竞争的，但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。

在这里插入图片描述
但，应注意：同一时刻，只能有一个线程持有该锁。

当 A 线程对某个全局变量加锁访问， B 在访问前尝试加锁，拿不到锁， B 阻塞。 C 线程不去加锁，而直接访问该全局变量，依然能够访问，但会出现数据混乱。

所以，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源的时候使用该机制。但，并没有强制限定。因此，即使有了 mutex，如果有线程不按规则来访问数据，依然会造成数据混乱



3.2 互斥锁的主要相关函数

  • pthread_mutex_t 类型
    • 其本质是一个结构体，为了简单理解，应用是可以忽略其实现细节，简单的当成整数看待
    • pthread_mutex_t mutex; // 变量mutex只有两种取值 1 、0

1 初始化互斥锁

/*
 * function: 初始化一个互斥锁(互斥量)------>初值可看成1
 *
 * function arguments:
 *  argv1: 传出参数，需要初始化的互斥锁变量，调用时应传&mutex
 *  argv2: 传入参数，互斥锁属性。通常传NULL(选用默认属性--线程间共享)
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                      const pthread_mutexattr_t *restrict attr);


// restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，
//                 只能通过本指针完成。

/*
 * 静态初始化：如果互斥锁mutex是静态分配的(定义在全局或者加了关键字static修饰),可以直接使用宏进行初始化。
 *             pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 *
 * 动态初始化：局部变量应该采用动态初始化
 *             pthread_mutex_init(&mutex, NULL);
 */

2 销毁互斥锁

/*
 * function: 销毁一个互斥锁
 *
 * function arguments:
 *  argv1: 需要销毁的互斥锁变量
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

int pthread_mutex_destroy(pthread_mutex_t *mutex);

3 加锁

/*
 * funcition: 对互斥锁加锁，可以理解为mutex--
 *
 * function arguments:
 *  argv1: 需要加锁的互斥锁变量
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

int pthread_mutex_lock(pthread_mutex_t *mutex);

4 解锁

/*
 * funcition: 对互斥锁解锁，可以理解为mutex++
 *
 * function arguments:
 *  argv1: 需要解锁的互斥锁变量
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

int pthread_mutex_unlock(pthread_mutex_t *mutex);

5 尝试加锁

/*
 * funcition: 尝试加锁
 *
 * function arguments:
 *  argv1: 尝试加锁的互斥锁变量
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

int pthread_mutex_trylock(pthread_mutex_t *mutex);

3.3 加锁与解锁

  1. lock 与 unlock
    lock 尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
    unlock 主动解锁函数， 同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。

  2. lock 与 trylock
    lock 加锁失败会阻塞，等待锁释放。
    trylock 加锁失败直接返回错误号（如： EBUSY），不阻塞。

3.4 互斥锁示例（使用互斥锁实现线程同步）

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

// 定义并初始化互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *MyThread(void *argv)
{
    while (1) 
    {   
        // 加锁
        pthread_mutex_lock(&mutex);
        printf("HELLO ");
        usleep(rand()%3);
        printf("WORLD\n");
        // 解锁
        pthread_mutex_unlock(&mutex);
        usleep(rand()%3);
    }   
}

int main()
{
    srand(time(NULL));
    pthread_t threadID;

    int ret = pthread_create(&threadID, NULL, MyThread, NULL);
    if (0 != ret)
    {   
        printf("pthread_create faild:%s\n", strerror(ret));
        exit(1);
    }   

    while (1) 
    {   
        // 加锁
        pthread_mutex_lock(&mutex);
        printf("hello ");
        usleep(rand()%3);
        printf("world\n");
        // 解锁
        pthread_mutex_unlock(&mutex);
        usleep(rand()%3);
    }

    // 销毁锁
    pthread_mutex_destroy(&mutex);

    return 0;
}

在这里插入图片描述
当线程同步后，不会在出现数据混乱的现象了。

在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”应越小越好。



4 死锁现象

  1. 线程试图对同一个互斥量 A 加锁两次。
  2. 线程 1 拥有 A 锁，请求获得 B 锁；线程 2 拥有 B 锁，请求获得 A 锁
    在这里插入图片描述
    在这里插入图片描述

如何解决死锁

  1. 让线程按照一定的顺序去访问共享资源
  2. 在访问其他锁的时候，需要先将自己的锁解开
  3. 调用pthread_mutex_trylock，如果加锁不成功立即返回


5 读写锁(rwlock)

5.1 读写锁的概念

读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是仪共享模式锁住的；当读写锁以写模式锁住时，它是以独占模式锁住的。读共享、写独占

5.2 读写锁的使用场合

读写锁非常适用于对数据结构读的次数远大于写的情况。

5.3 读写锁的特性

  1. 读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。
  2. 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
  3. 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。 读锁、写锁并行阻塞，写锁优先级高

5.4 读写锁的主要相关函数

  • pthread_rwlock_t 类型 用于定义一个读写锁变量
    • pthread_rwlock_t rwlock;

1 读写锁初始化

/*
 * function: 初始化读写锁
 *
 * function arguments:
 *  argv1: 读写锁
 *  argv2: 读写锁属性，传NULL为默认属性
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */

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

2 销毁读写锁

/*
 * function: 销毁读写锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

3 加读锁

/*
 * function: 加读锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

4 尝试加读锁

/*
 * function: 尝试加读锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

5 加写锁

/*
 * function: 加写锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

6 尝试加写锁

/*
 * function: 尝试加写锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

7 解锁

/*
 * function: 解锁
 *
 * function arguments:
 *  argv1: 读写锁
 *
 *  return value:
 *   success: 返回0
 *   faild: 返回错误号
 */
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

5.5 读写锁示例

/* 3 个线程不定时写同一全局资源， 5 个线程不定时读同一全局资源 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

// 全局变量
int g_counter;

// 定义读写锁
pthread_rwlock_t rwlock;

void *RDThread(void *argv)
{
    int ii = *(int *)argv;

    while (1)
    {
        // 加读锁
        pthread_rwlock_rdlock(&rwlock);
        printf("read  第%d个线程, 线程号:%lu, 读全局变量:%d\n", ii, pthread_self(), g_counter);
        // 解锁
        pthread_rwlock_unlock(&rwlock);
        usleep(2000);
    }   

    pthread_exit(NULL);
}
void *WRThread(void *argv)
{
    int t;
    int ii = *(int *)argv;

    while (1) 
    {   
        // 加写锁
        pthread_rwlock_wrlock(&rwlock);
        t = g_counter;
        printf("write 第%d个线程, 线程号:%lu, 写全局变量:%d->%d\n", ii, pthread_self(), t, ++g_counter);
        // 解锁
        pthread_rwlock_unlock(&rwlock);
        usleep(2000);
    }   

    pthread_exit(NULL);
}

int main()
{
    int ii;
    pthread_t threadID[8];

    // 初始化读写锁
    pthread_rwlock_init(&rwlock, NULL);

    for(ii = 0; ii < 3; ++ii)
        pthread_create(&threadID[ii], NULL, RDThread, (void*)&ii);
    for(; ii < 8; ++ii)
        pthread_create(&threadID[ii], NULL, WRThread, (void*)&ii);

    for(ii = 0; ii < 8; ++ii)
        pthread_join(threadID[ii], NULL);

    // 销毁读写锁
    pthread_rwlock_destroy(&rwlock);

    pthread_exit(NULL);
}
linuxcpp_
关注
专栏目录
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
Boss_peng的博客
06-05 461
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
android 线程互斥锁,多线程编程-互斥锁
weixin_27127993的博客
05-29 902
1．引言：互斥锁，是一种信号量，常用来防止两个进程或线程在同一时刻访问相同的共享资源。可以保证以下三点：原子性：把一个互斥量锁定为一个原子操作，这意味着操作系统(或pthread函数库)保证了如果一个线程锁定了一个互斥量，没有其他线程在同一时间可以成功锁定这个互斥量。唯一性：如果一个线程锁定了一个互斥量，在它解除锁定之前，没有其他线程可以锁定这个互斥量。非繁忙等待：如果一个线程已经锁定了一个互斥量...
Linux线程同步(二)---互斥锁实现线程同步
myselfzhangji的博客
09-05 418
一 why 先给自己打个广告，本人的微信公众号:嵌入式Linux江湖，主要关注嵌入式软件开发，股票基金定投，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题。 在博客《Linux线程同步(一)—“初识篇”》中，介绍了为什么需要线程同步，从本篇博客开始介绍如何实现线程同步，本篇主要介绍的是互斥锁实现线程同步。 二 how 互斥锁：只能被一个线程拥有，比如线程A拥有了这把锁，其他线程都无法拥有这把锁。只有获得这把锁的线程才可以访问临界区,其他没有获得这把锁的线程都无法访问临界区
linux线程互斥锁函数,[Linux线程]线程的同步--使用互斥锁完成线程同步
weixin_30962449的博客
05-03 125
#include#include#includepthread_mutex_tmutex;//定义一个互斥量intx;//定义一个全局变量//这是线程1的入口函数voidthreaddeal1(void){while(x>0)//如果X>0{pthread_mutex_lock(&mutex...
linux线程同步方式1——互斥锁（mutex）
JMW1407的博客
06-13 1134
互斥锁（mutex）互斥体互斥锁1、定义2、属性3、使用流程（相关API函数）pthread_mutex_init()1、定义2、函数原型：3、返回值:4、初始化方式pthread_mutex_destroy（）1、定义2、函数原型pthread_mutex_lock（）(阻塞）1、定义2、函数原型3、基于mutex类型的返回值pthread_mutex_unlock（）1、定义2、函数原型互斥锁应用举例参考 互斥体 互斥体实现了“互相排斥”（mutual exclusion）同步的简单形式（所以名为互斥
嵌入式linux 线程互锁,《重要》内核下各种同步处理方法（自旋锁、信号灯、互斥体…）...
weixin_42490521的博客
05-10 223
1.在支持多线程的操作系统下，有些函数会出现不可重入的现象。所谓“可重入”是指函数的执行结果不和执行顺序有关。反之如果执行结果和执行顺序有关，则称这个函数是“不可重入”的。2.Windows将中断的概念进行了扩展，提出一个中断请求级(IRQL)的概念。其中规定了32个中断请求级别，分别是0~2级别为软件中断，3~31级为硬件中断，其中数字从0~31，优先级别逐次递增。在内核模式下，可以通过调用Ke...
C++-多线程数据共享问题和互斥锁
mrbone11的博客
11-14 1937
文章目录线程数据共享问题不变式与竞争条件避免竞争条件互斥锁 线程数据共享问题 多线程的优势之一就是线程之间可以共享数据，但我们需要一套规则规定哪个线程可以访问哪部分数据，什么时候可以访问，以及怎么通知其他关心该数据的线程已经更新了数据，如果不能处理好数据共享的问题，多线程的这个优势也会变为劣势。 线程间共享数据的所有问题都是因为对数据的修改，一个只读的数据不会造成任何问题。 不变式与竞争条件 这里要提到一个概念：不变式（invariant），意思是关于特定数据结构的陈述始终正确。例如：“x变量保存着列表中元
linux多线程 -- 读写互斥锁（7）
qinjie的博客
11-25 281
一、读写锁是什么？ 读写锁其实还是一种锁，是给一段临界区代码加锁，但是此加锁是在进行写操作的时候才会互斥，而在进行读的时候是可以共享的进行访问临界区的。 读写锁和互斥量（互斥锁）很类似，是另一种线程同步机制，但不属于POSIX标准，可以用来同步同一进程中的各个线程。当然如果一个读写锁存放在多个进程共享的某个内存区中，那么还可以用来进行进程间的同步， 读写锁的使用规则： 只要没有写模式下的加锁，任意线程都可以进行读模式下的加锁； 只有读写锁处于不加锁状态时，才能进行写模式下的加锁； 读写锁也称为共享
Linux多线程同步机制—读写锁(Read-Write Lock)
wjianwei666的专栏
07-09 889
读写锁（Read-Write Lock）是一种线程同步机制，用于管理对共享资源的访问。与互斥锁（Mutex）不同，读写锁允许多个线程同时以读模式访问共享资源，但只允许一个线程以写模式访问资源。这种机制特别适用于读操作远多于写操作的场景，可以显著提高程序的并发性能。自定义实现读写锁代码需要开发者更深入地理解读写锁的底层实现原理。完全自行实现读写锁的逻辑，通过互斥锁、条件变量以及自定义的读计数和写标志来管理读写操作的同步。// 定义读写锁结构体// 互斥锁，用于保护读写锁的内部状态。
linux多线程-----同步机制(互斥量、读写锁、条件变量)
Be The Best！
03-23 3427
linux多线程-----同步机制(互斥量、读写锁、条件变量)
Linux 多线程安全之----死锁问题
flyingcloud6的博客
12-07 1267
这时候我们来通过pstack来查看下调用堆栈我们可以看到创建出来的两个线程只剩下了一个，并且他在死等锁2.接下来我们来模拟一个线程将锁锁上没有释放，再次去申请锁，导致死锁的情况： 我们再来看看调用堆栈，可以发现和上面一样，同样是在死等锁吃着碗里的，看着锅里的 这两个线程A和B都阻塞在自己的加锁逻辑当中去了我们来写代码模拟一下这个过程，创建一个线程A和线程B 这时候查看调用堆栈，发现两个线程都在等待着锁，导致卡死了先使用gdb attach 【pid】命令进入gdb调试状态 这时候再使用 thread ap
Linux线程同步(三)---互斥锁源码分析
myselfzhangji的博客
10-31 1987
linux互斥锁源码分析
线程同步机制（互斥量，读写锁，自旋锁，条件变量，屏障）
poison_biti的博客
08-04 3277
先知：      （1）线程是由进程创建而来，是cpu调度的最小单位。      （2）每个进程都有自己独立的地址空间，而进程中的多个线程共用进程的资源，他们只有自己独立的栈资源。 线程同步：      当多个控制线程共享相同的内存时，需要确保每个进程看到一致的数据视图。同一个数据如果被两个及以上的线程进行同时访问操作的时候，有可能就会造成数据不一致的现象。为了解决这个问题，线程不
linux线程互斥与同步（part1）—互斥锁（mutex）的原理及其实现机制
热门推荐
My Coding Life
05-25 1万+
一段代码引发的问题首先，我们来编写一段代码，它的目的是定义一个全局变量，创建两个线程对其进行5000++的操作。运行结果如下： 当然，目前来看，这段程序并没有任何的问题。然而，对于此程序，结合线程的特点，我们需要明确两点： 局部变量 i 不是共享的，因为它在栈中 gCount是共享的，因为它是全局变量，属于代码段。 我们知道，只要是共享的资源，那么它就可以看作临界资源，而临界资源的访问需要同步与互
线程同步---互斥锁和读写锁
一条二哈
01-09 1471
同步概念 所谓同步，即同时起步，协调一致。不同的对象，对“同步”的理解方式略有不同。如，设备同步，是指在两个设备之间规定一个共同的时间参考；数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持一致；文件同步，是指让两个或多个文件夹里的文件保持一致。等等 但是在编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相配合。主旨在协同步调，按预定的先...
互斥锁，读写锁，条件变量，自旋锁
yao5hed的专栏
08-30 1387
互斥锁 在多线程的情况下，当一个变量可以被多个线程修改时，就需要考虑多线程同步问题。线程A修改变量前，先加锁，修改结束再解锁，然后线程B获取同样的锁，修改结束再解锁，如果不是同一把锁，同步是无效的。 在C++中使用pthread的互斥量接口实现数据同步，线程A对互斥量mutex加锁后，其他尝试加锁的线程都会阻塞，等线程A解锁后，其他线程从阻塞变为运行态，第一个抢到CPU的线程加锁成功，其他线程...
线程安全(内部锁Synchronized和显示锁Lock)
骆超
09-03 2880
线程安全问题的产生？ 多个线程并发访问共享数据 锁(Lock)的概述 线程安全问题是因为多个线程并发访问共享数据。于是很容易我们就想到将多个线程对共享数据的访问转换为串行访问。同一时刻只能有一个线程来访问共享数据。锁就是利用这种思路来保障线程安全的一种同步机制 锁可以理解为对共享数据保证的许可证。一个线程只有在持有许可证的情况下才能访问共享数据，在结束共享数据的访问之后必须释放许可证，以...
Linux 再入门整理：详解 /etc/fstab 文件
一只奋斗的猪
10-01 1341
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
【Linux】进程地址空间(初步了解)
最新发布
weixin_69380220的博客
10-04 1428
进程虚拟地址空间相关内容
Linux高级程序设计：线程同步与读写锁机制
"本资源主要介绍了Linux环境下线程间同步的各种机制，包括互斥锁、条件变量、读写锁以及线程与信号的通信方式。这些内容出自《Linux高级程序设计(第2版)》，由杨宗德编著，人民邮电出版社于2009年9月出版。书中详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值