Linux 互斥锁 读写锁 条件变量 信号量 （备查）

于 2023-12-02 18:55:05 发布
阅读量1.3k 收藏 17
点赞数 36
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CYS_2020/article/details/134744209
版权

线程同步

1）所谓的同步并不是多个线程同时对内存进行访问，而是按照先后顺序依次进行的。
2）如没有对线程进行同步处理，会导致多个线程访问共享资源出现数据混乱的问题。
3）所谓共享资源就是多个线程共同访问的变量，这些变量通常为全局数据区变量或者堆区变量，这些变量对应的共享资源也被称之为临界资源。

4）常用的线程同步方式有四种：互斥锁、读写锁、条件变量、信号量。

5）通过锁机制能保证临界区代码最多只能同时有一个线程访问，这样并行访问就变为串行访问了。

互斥锁

1）通过互斥锁可以锁定一个代码块, 被锁定的这个代码块, 所有的线程只能顺序执行(不能并行处理)，需要付出的代价就是执行效率的降低。

1）一个互斥锁变量只能被一个线程锁定，被锁定之后其他线程再对互斥锁变量加锁就会被阻塞，直到这把互斥锁被解锁，被阻塞的线程才能被解除阻塞。
2）一般情况下，每一个共享资源对应一把互斥锁。

创建互斥锁
//在Linux中互斥锁的类型为pthread_mutex_t，创建一个这种类型的变量就得到了一把互斥锁：
pthread_mutex_t  mutex;

// 初始化互斥锁
// restrict: 是一个关键字, 用来修饰指针, 只有这个关键字修饰的指针可以访问指向的内存地址, 其他指针是不行的
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
           			   const pthread_mutexattr_t *restrict attr);
参数:
	mutex: 互斥锁变量的地址
	attr: 互斥锁的属性, 一般使用默认属性即可, 这个参数指定为NULL  
	
//函数调用成功会返回0，调用失败会返回相应的错误号：
加锁
// 修改互斥锁的状态, 将其设定为锁定状态, 这个状态被写入到参数 mutex 中
int pthread_mutex_lock(pthread_mutex_t *mutex);

这个函数被调用, 首先会判断参数 mutex 互斥锁中的状态是不是锁定状态
1）如果被锁定了, 其他线程加锁就失败了, 这些线程都会阻塞在这把锁上。
2）当这把锁被解开之后, 这些阻塞在锁上的线程就解除阻塞。
3）没抢到锁的线程继续阻塞。

// 尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);

调用这个函数对互斥锁变量加锁还是有两种情况:
1）如果这把锁没有被锁定是打开的，线程加锁成功
2）如果锁变量被锁住了，调用这个函数加锁的线程，不会被阻塞，加锁失败直接返回错误号

解锁
// 对互斥锁解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

1）不是所有的线程都可以对互斥锁解锁，哪个线程加的锁, 哪个线程才能解锁成功。

释放互斥锁
// 释放互斥锁资源            
int pthread_mutex_destroy(pthread_mutex_t *mutex);

//函数调用成功会返回0，调用失败会返回相应的错误号：
死锁

1）锁使用不当, 就会造成死锁现象
2）线程死锁造成的后果是：使用这个共享资源的线程都被阻塞

造成死锁的场景有如下几种：
1）加锁之后忘记解锁。
2）重复加锁, 只解锁一次，造成死锁。
3）有多个共享资源, 两个线程交叉锁定了另一个线程的必要资源。

读写锁

读锁是共享的。写锁是独占的。

1）读写锁是互斥锁的升级版, 在做读操作的时候可以提高程序的执行效率。
2）读写锁是一把锁，可以做写锁定和读锁定两件事。
3）写锁的优先级高于****读锁。

创建读写锁
//在Linux中读写锁的类型为pthread_rwlock_t，创建一个这种类型的变量就得到了一把读写锁
pthread_rwlock_t rwlock;

在这把锁中大致记录了这些信息：
1）锁的状态: 锁定/打开。
2）锁定的是什么操作: 读操作/写操作，使用读写锁锁定了读操作，需要先解锁才能去锁定写操作。
3）哪个线程将这把锁锁上了。

// 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
           				const pthread_rwlockattr_t *restrict attr);
参数:
	rwlock: 读写锁的地址，传出参数
	attr: 读写锁属性，一般使用默认属性，指定为NULL
加读锁
// 对读写锁加读锁, 锁定的是读操作
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);
释放读写锁
// 释放读写锁占用的系统资源
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
其他

如果说程序中所有的线程都对共享资源做写操作，使用读写锁没有优势，和互斥锁是一样的，
如果说程序中所有的线程都对共享资源有写也有读操作，并且对共享资源读的操作越多，读写锁更有优势。

条件变量

1）条件变量的主要作用不是处理线程同步, 而是进行线程的阻塞。
2）一般情况下条件变量用于处理生产者和消费者模型，并且和互斥锁配合使用。

创建条件变量
//条件变量类型为 pthread_cond_t，这样就定义一个条件变量类型的变量了
pthread_cond_t cond;

被条件变量阻塞的线程的线程信息会被记录到这个变量中，以便在解除阻塞的时候使用。

// 初始化条件变量
int pthread_cond_init(pthread_cond_t *restrict cond,
     				  const pthread_condattr_t *restrict attr);
参数:
	cond: 条件变量的地址
	attr: 条件变量属性, 一般使用默认属性, 指定为NULL
阻塞线程
// 线程阻塞函数, 哪个线程调用这个函数, 哪个线程就会被阻塞
int pthread_cond_wait(pthread_cond_t *restrict cond, 	//条件变量
					  pthread_mutex_t *restrict mutex);	//互斥锁

在阻塞线程的时候，需要一个互斥锁参数，这个互斥锁主要功能是进行线程同步

该函数会对这个互斥锁做以下几件事情：
1）在阻塞线程时候，如果线程已经对互斥锁mutex上锁，那么会将这把锁打开，这样做是为了避免死锁
2）当线程解除阻塞的时候，函数内部会帮助这个线程再次将这个mutex互斥锁锁上，继续向下访问临界区

// 表示的时间是从1971.1.1到某个时间点的时间, 总长度使用秒/纳秒表示
struct timespec {
	time_t tv_sec;      /* Seconds */
	long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */
};
// 将线程阻塞一定的时间长度, 时间到达之后, 线程就解除阻塞了
int pthread_cond_timedwait(pthread_cond_t *restrict cond,	//条件变量
           				   pthread_mutex_t *restrict mutex,	//互斥锁
           				   const struct timespec *restrict abstime);//表示线程阻塞的时长

struct timespec这个结构体中记录的时间是从1971.1.1到某个时间点的时间，总长度使用秒/纳秒表示。

time_t mytim = time(NULL);	// 1970.1.1 0:0:0 到当前的总秒数

struct timespec tmsp;
tmsp.tv_sec = time(NULL) + 100;	// 线程阻塞100s
tmsp.tv_nsec = 0;//初始化为0,避免出错
唤醒线程
// 唤醒阻塞在条件变量上的线程, 至少有一个被解除阻塞
int pthread_cond_signal(pthread_cond_t *cond);

// 唤醒阻塞在条件变量上的线程, 被阻塞的线程全部解除阻塞
int pthread_cond_broadcast(pthread_cond_t *cond);

1)调用上面两个函数中的任意一个，都可以唤醒被 pthread_cond_wait 或者 pthread_cond_timedwait 阻塞的线程，
2)区别就在于 pthread_cond_signal 是唤醒至少一个被阻塞的线程（总个数不定）， pthread_cond_broadcast 是唤醒所有被阻塞的线程。

释放条件变量
// 销毁释放资源        
int pthread_cond_destroy(pthread_cond_t *cond);

信号量

创建信号量
//信号的类型为sem_t对应的头文件为<semaphore.h>
#include <semaphore.h>
sem_t sem;

// 初始化信号量/信号灯
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数:
	sem：信号量变量地址
	pshared：
			0：线程同步
			非0：进程同步
	value：初始化当前信号量拥有的资源数（>=0），如果资源数为0，线程就会被阻塞了。
判断 是否阻塞
// 函数被调用sem中的资源就会被消耗1个, 资源数-1
int sem_wait(sem_t *sem);	//阻塞

1)sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，因此线程也就被阻塞了。

// 函数被调用sem中的资源就会被消耗1个, 资源数-1
int sem_trywait(sem_t *sem);	//不阻塞

1)并且sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，但是线程不会被阻塞，直接返回错误号，
3)因此可以在程序中添加判断分支，用于处理获取资源失败之后的情况。

// 表示的时间是从1971.1.1到某个时间点的时间, 总长度使用秒/纳秒表示
struct timespec {
	time_t tv_sec;      /* Seconds */
	long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */
};
// 调用该函数线程获取sem中的一个资源，当资源数为0时，线程阻塞，在阻塞abs_timeout对应的时长之后，解除阻塞。
// abs_timeout: 阻塞的时间长度, 单位是s, 是从1970.1.1开始计算的
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

1)sem中的资源数>0，线程不会阻塞，线程会占用sem中的一个资源，因此资源数-1，
2)直到sem中的资源数减为0时，资源被耗尽，线程被阻塞，
3)当阻塞指定的 abs_timeout 时长之后，线程解除阻塞。

唤醒阻塞 线程
// 调用该函数给sem中的资源数+1
int sem_post(sem_t *sem);

1)该函数会将sem中的资源数+1，
2)如果有线程在调用 sem_wait、sem_trywait、sem_timedwait 时因为sem中的资源数为0被阻塞了，这时这些线程会解除阻塞，获取到资源之后继续向下运行。

获取现有可用资源数
// 查看信号量 sem 中的整形数的当前值, 这个值会被写入到sval指针对应的内存中
int sem_getvalue(sem_t *sem, int *sval);

// sval是一个传出参数

1)这个函数可以查看sem中现在拥有的资源个数，通过第二个参数 sval 将数据传出，
2)也就是说第二个参数的作用和返回值是一样的。

释放信号量
// 参数 sem 就是 sem_init() 的第一个参数            
int sem_destroy(sem_t *sem);

// 资源释放, 线程销毁之后调用这个函数即可

其他

生产者和消费者 模型+案列

在这里插入图片描述

-------------------生产者消费者 案列(使用条件变量)-----------------------------
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

// 链表的节点
struct Node
{
    int number;
    struct Node* next;
};

// 定义条件变量, 控制消费者线程
pthread_cond_t cond;
// 互斥锁变量
pthread_mutex_t mutex;
// 指向头结点的指针
struct Node * head = NULL;

// 生产者的回调函数
void* producer(void* arg)
{
    // 一直生产
    while(1)
    {
        pthread_mutex_lock(&mutex);
        // 创建一个链表的新节点
        struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
        // 节点初始化
        pnew->number = rand() % 1000;
        // 节点的连接, 添加到链表的头部, 新节点就新的头结点
        pnew->next = head;
        // head指针前移
        head = pnew;
        printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
        pthread_mutex_unlock(&mutex);

        // 生产了任务, 通知消费者消费
        pthread_cond_broadcast(&cond);

        // 生产慢一点
        sleep(rand() % 3);
    }
    return NULL;
}

// 消费者的回调函数
void* consumer(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        // 一直消费, 删除链表中的一个节点
//        if(head == NULL)   // 这样写有bug
        while(head == NULL)
        {
            // 这函数会自动将线程拥有的锁解开
            pthread_cond_wait(&cond, &mutex);
            // 当消费者线程解除阻塞之后, 会自动将这把锁锁上
            // 这时候当前这个线程又重新拥有了这把互斥锁
        }
        // 取出链表的头结点, 将其删除
        struct Node* pnode = head;
        printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
        head  = pnode->next;
        free(pnode);
        pthread_mutex_unlock(&mutex);        

        sleep(rand() % 3);
    }
    return NULL;
}

int main()
{
    // 初始化条件变量
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);

    // 创建5个生产者, 5个消费者
    pthread_t ptid[5];
    pthread_t ctid[5];
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ptid[i], NULL, producer, NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_create(&ctid[i], NULL, consumer, NULL);
    }

    // 释放资源
    for(int i=0; i<5; ++i)
    {
        // 阻塞等待子线程退出
        pthread_join(ptid[i], NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_join(ctid[i], NULL);
    }

    // 销毁条件变量
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    return 0;
}
顺序执行的线程 案列

1)如果生产者和消费者线程使用的信号量对应的总资源数为1，那么不管线程有多少个，可以工作的线程只有一个，其余线程由于拿不到资源，都被迫阻塞了。

且不会出现生产者线程和消费者线程同时访问共享资源的情况，不管生产者和消费者线程有多少个，它们都是顺序执行的。(可不使用互斥锁)

----------------顺序执行的线程 案列------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>

// 链表的节点
struct Node
{
    int number;
    struct Node* next;
};

// 生产者线程信号量
sem_t psem;
// 消费者线程信号量
sem_t csem;

// 互斥锁变量
pthread_mutex_t mutex;
// 指向头结点的指针
struct Node * head = NULL;

// 生产者的回调函数
void* producer(void* arg)
{
    // 一直生产
    while(1)
    {
        // 生产者拿一个信号灯
        sem_wait(&psem);
        // 创建一个链表的新节点
        struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
        // 节点初始化
        pnew->number = rand() % 1000;
        // 节点的连接, 添加到链表的头部, 新节点就新的头结点
        pnew->next = head;
        // head指针前移
        head = pnew;
        printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());

        // 通知消费者消费, 给消费者加信号灯
        sem_post(&csem);
        

        // 生产慢一点
        sleep(rand() % 3);
    }
    return NULL;
}

// 消费者的回调函数
void* consumer(void* arg)
{
    while(1)
    {
        sem_wait(&csem);
        // 取出链表的头结点, 将其删除
        struct Node* pnode = head;
        printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
        head  = pnode->next;
        free(pnode);
        // 通知生产者生成, 给生产者加信号灯
        sem_post(&psem);

        sleep(rand() % 3);
    }
    return NULL;
}

int main()
{
    // 初始化信号量
    // 生产者和消费者拥有的信号灯的总和为1
    sem_init(&psem, 0, 1);  // 生成者线程一共有1个信号灯
    sem_init(&csem, 0, 0);  // 消费者线程一共有0个信号灯

    // 创建5个生产者, 5个消费者
    pthread_t ptid[5];
    pthread_t ctid[5];
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ptid[i], NULL, producer, NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_create(&ctid[i], NULL, consumer, NULL);
    }

    // 释放资源
    for(int i=0; i<5; ++i)
    {
        pthread_join(ptid[i], NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_join(ctid[i], NULL);
    }

    sem_destroy(&psem);
    sem_destroy(&csem);

    return 0;
}


作者: 苏丙榅
链接: https://subingwen.cn/linux/thread-sync/?highlight=%E7%BA%BF%E7%A8%8B%E5%90%8C%E6%AD%A5
来源: 爱编程的大丙
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

详细教程可转

爱编程的大丙

陈远松
关注
  • 36
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Linux】线程同步——信号量、读写锁和条件变量
维欣~fighting✔
05-27 213
一、信号量 1、和进程类似，信号量就是特殊的计数器。 可以参考进程间通信——信号量 2、多线程的信号量操作是在全局进行定义 信号量类型sem_t 3、初始化 int sem_init(sem_t *sem, int shared, int val); 4、P操作 int sem_wait(sem_t *sem); 5、V操作 int sem_post(sem_t *sem); 6、销毁 int sem_destory(sem_t *sem); ...
利用进程信号量实现读写锁
HappyMrSpring
02-22 1152
static struct sembuf hms_rl[2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} static struct sembuf hms_wl[2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} }; static struct sembuf hms_url[1] = { {0, -1, SEM_...
信号量实现读写锁
weixin_41672404的博客
05-13 419
写优先 int count=0;//读者数量 int mutex=1;//对count的互斥信号量 int rw=1;//读写互斥 int w=1;//写者等待队列 void wrriter { while(1) { p(w);//写者等待队列为空 p(rw);//读写互斥 wrrite; v(rw); v(w); } } void reader() { while(1) { p(w);//没有写者等待 p(mutex) if(count==0) p(rw)
利用信号实现写优先的读写锁
weixin_30387339的博客
09-24 131
　　以前利用linux系统提供的读写锁写过一些小程序，但是linux系统提供的读写锁是线程级的，如果是进程间的同步的话，就没那么轻松了。而且由于linux系统提供的读写锁是读优先的，在有些情况下，也不能满足我们的要求。下面就说说利用信号量来实现写优先的读写锁。 　　先说说原理，这个程序需要用到两个信号量，一个互斥信号量A，一个同步信号量B，其拥有MAX_RESOURCES个资源。当读进...
实现线程读写锁的四种方法
热门推荐
LUCKYOJ
05-07 1万+
对于某个临界互斥资源， 读写锁：当已经被加了读锁时，其他的读模式锁请求仍然可以访问，但是写模式锁不能访问；当写模式锁加锁时，其他的请求都不能访问。
Linux互斥锁、条件变量和信号量
12-29
Linux互斥锁、条件变量和信号量 Linux互斥锁、条件变量和信号量 Linux互斥锁、条件变量和信号量 Linux互斥锁、条件变量和信号量 Linux互斥锁、条件变量和信号量 Linux互斥锁、条件变量和信号量 Linux互斥锁、条件...
浅谈互斥锁为什么还要和条件变量配合使用
01-10
而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起配合使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。...
Linux互斥锁、条件变量和信号量[归类].pdf
10-11
Linux 互斥锁、条件变量和信号量 在 Linux 多线程编程中，为了防止多个线程同时访问共享资源，Linux 提供了互斥锁、条件变量和信号量来保护共享资源。 一、互斥锁 互斥锁是一种信号量，常用来防止两个进程或线程...
Linux C 多线程编程之互斥锁与条件变量实例详解
07-14
在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化: 对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init. 对于动态分配的互斥量, 在申请...
c-互斥锁 读写锁 信号量
qq_30861013的博客
01-29 412
互斥锁 pthread_mutext_t mutext; # include <stdio.h> # include <pthread.h> pthread_mutex_t mute; int value = 0; void *fun(void *arg){ //上锁，函数是阻塞的 pthread_mutex_lock(&mute); printf("now is %d and old value is %d \n",*((int *)arg)
多线程编程4：linux线程同步(信号量和读写锁)
yubaoaihh
08-04 107
linux线程同步(信号量和读写锁)
线程安全：信号量、互斥锁、读写锁、条件变量
weixin_ysc18398079698的博客
07-07 104
1.1、使用 sem_open( )来创建或者打开一个有名信号量。（1）参数：name是给信号量指定一个名字。oflag的值为O_CREAT,表示如果信号量不存在，创建信号量；为O_CREAT|O_EXCL,如果信号量不存在报错。mode为信号量的权限（0644）。value为信号量的值。（2）返回值:成功时，返回信号量的指针，错误返回SEM_FAILED1.2、使用 sem_wait( )和 sem_post( )来分别进行 P 操作和 V 操作。（1）参数:sem为信号量的指针。
Linux——线程信号量 读写锁 线程的私有数据
宁静致远
10-25 545
回顾：         线程与进程         1.进程由于资源独立，进程的主要关注是解决资源共享         2.线程先天是数据共享,线程主要关注共享数据脏                 1.互斥量(线程内)                          读写锁                                  2.信号/条件量调度(线程之间)
张氏读写锁，c++信号量实现
张人杰的博客
12-19 637
ReadWriteLock.h #pragma once #include class ReadWriteLock { public: ReadWriteLock(void); ~ReadWriteLock(void); void LockRead(void); void LockWrite(void); std::mutex m_lock_writeCount;
信号量和读写锁
qq_38712943的博客
09-07 1442
六、信号量 关于信号量的内容，实际上它是与自旋锁类似的概念，只有得到信号量的进程才能执行临界区的代码；不同的是获取不到信号量时，进程不会原地打转而是进入休眠等待状态。它的定义是include\linux\semaphore.h文件中，结构体如图6.1所示。其中的count变量是计数作用，通过使用lock变量实现对count变量的保护，而wait_list则是对申请信号量的进程维护的等待队列。  ...
用信号量和读写锁解决读者写者问题
weixin_34378767的博客
03-20 386
读者写者问题是非常经典的同步问题，本文首先用信号量来解决这个问题，并结合代码分析什么是读者优先、什么是写者优先，然后给出读写锁的解决方案，并指出在Linux下读写锁的注意事项。   读者写者问题 　　读者写者问题描述的是这么一种情况：对象在多个线程（或者进程）之间共享，其中一些线程只会读数据，另外一些线程只会写数据。为了保证写入和读取的正确性，我们需要保证，只要有线程在写，那么其他线程不能读...
educoder : Linux之线程同步二(3)
LIAO_sir的博客
11-13 2464
项目实战
同步--互斥锁与条件变量、读写锁、信号量
weixin_41884844的博客
07-16 208
互斥锁与条件变量 互斥量 1.静态分配互斥量 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER 2.动态分配互斥量 pthread_mutex_init(&mutex); & pthread_mutex_destory(&mutex); //操作： 1.pthread_mutex_lock 加锁 2.pthread_...
互斥锁、读写锁、条件变量、信号量、屏障 这几个举几个例子
最新发布
09-13
互斥锁、读写锁、条件变量、信号量、屏障是操作系统中常用的同步原语，用于多线程或多进程之间的协调和同步。下面举几个例子来说明它们的应用： 1. 互斥锁： 互斥锁是最常见且基础的同步原语，用来保护临界区，确保...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值