linux 多线程同步 2019.1.9（互斥量的使用，死锁，读写锁，条件变量，信号量，文件锁）

最新推荐文章于 2024-05-04 16:40:04 发布
最新推荐文章于 2024-05-04 16:40:04 发布
阅读量559 收藏
点赞数 1
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86126197
版权

学习目标

 

 

互斥量的使用

 

 

lock和unlock的使用例子

 

通过互斥量，两个线程交替打印

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

//常量初始化锁——mutex(这样就不用init函数了)，将其定义为全局变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int sum=0;

void *thr1(void *arg)
{
    while(1){
		//先上锁
        pthread_mutex_lock(&mutex);
        printf("hello");
        sleep(rand()%3);
        printf("world\n");
		//释放锁
        pthread_mutex_unlock(&mutex);
		sleep(rand()%3);
    }
}

void *thr2(void *arg)
{
    while(1){
        pthread_mutex_lock(&mutex);
        printf("HELLO");
        sleep(rand()%3);
        printf("WORLD\n");
        pthread_mutex_unlock(&mutex);
        sleep(rand()%3);
    }
}


int main()
{
    pthread_t tid[2];
    pthread_create(&tid[0],NULL,thr1,NULL);
    pthread_create(&tid[1],NULL,thr2,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);
    return 0;
}

 

 

trylock

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

pthread_mutex_t mutex;


void *thr(void *arg)
{
    while(1){
        pthread_mutex_lock(&mutex);
        printf("hello world\n");
        sleep(30);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}


int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_t tid;
    pthread_create(&tid,NULL,thr,NULL);
    sleep(1);
    while(1){
        int ret = pthread_mutex_trylock(&mutex);
		//加锁失败
        if(ret > 0){
            printf("ret = %d,srrmsg:%s\n",ret,strerror(ret));
        }
        sleep(1);
    }
    return 0;
}

返回值的错误码是16，我们来看一下16代表什么意思。

 

错误码定义的地方

 

 

 

死锁

产生条件

  • 锁了又锁，自己加了锁，自己又加了一把锁。一般都是有分支或者写代码的时候忘了会出现这个问题
  • 交叉锁（如下图所示）——解决方案：1、每个线程申请锁的顺序要一致；2、如果申请到一把锁，另一个申请不到，则释放已有资源

互斥量只是建议锁

 

 

 

读写锁

读共享，写互斥，写的优先级高。适合读的线程多的场景

读写锁仍然是一把锁，有不同的状态：

  • 未加锁
  • 读锁
  • 写锁

 

读写锁练习场景

 

 

初始化

 

一种初始化的方式

 

 

另一种初始化的方式

 

 

销毁读写锁

 

 

读写锁的例子

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

//初始化
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
int beginnum = 1000;

void *thr_write(void *arg) {
    while(1){
		//写锁加锁
        pthread_rwlock_wrlock(&rwlock);
        printf("---%s---self---%lu---beginnum---%d\n",__FUNCTION__,pthread_self(),++beginnum);
        usleep(2000);//模拟占用时间
		//解锁
        pthread_rwlock_unlock(&rwlock);
        usleep(4000);
    }
    return NULL;
}

void *thr_read(void *arg) {
    while(1){
		//读锁加锁
        pthread_rwlock_rdlock(&rwlock);
        printf("---%s---self---%lu---beginnum---%d\n",__FUNCTION__,pthread_self(),beginnum);
        usleep(2000);//模拟占用时间
		//解锁
        pthread_rwlock_unlock(&rwlock);
        usleep(2000);

    }
    return NULL;
}

int main(){
	//创建5个读锁和3个写锁
    int n  =8,i = 0;
    pthread_t tid[8];//5-read ,3-write 
    for(i = 0; i < 5; i ++){
		//参数依次是线程地址、线程属性、函数名、传入的参数
        pthread_create(&tid[i],NULL,thr_read,NULL);
    }
    for(;i < 8; i ++){
		//参数依次是线程地址、线程属性、函数名、传入的参数
        pthread_create(&tid[i],NULL,thr_write,NULL);
    }

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

 

 

 

 

条件变量

引入原因：mutex会产生如下问题

多个线程抢到锁之后，发现并没有资源，因此释放锁，然后继续多线程抢锁，然后释放锁，这户造成资源的浪费。

三个吃货抢锁，抢到的人打开饼筐发现没有饼，于是释放锁，然后三个吃货继续抢锁。

 

条件变量可以引起阻塞，并非锁，要和互斥变量组合使用

 

 

超时等待

 

传入参数中的timespec结构体：

 

 

条件变量阻塞等待

 

使用条件变量解决问题的例子

两个线程，一个线程想把所有的内容都写成0，另一个线程想把所有的内容都写成1

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>

pthread_mutex_t mutex ;

char buf[20];

void *thr1(void *arg){

    int i = 0 ;
    //加锁
    pthread_mutex_lock(&mutex);
    for(;i< 20; i ++){
        usleep(rand()%3);
        buf[i] = '0';
    }
    //解锁
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void *thr2(void *arg) {
    int i = 0 ;
    //加锁
    pthread_mutex_lock(&mutex);
	for (; i < 20; i++) {
		usleep(rand() % 3);
		buf[i] = '1';
	}
    //解锁
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main(){
    //两个线程，一个线程想把所有的内容都写成0，另一个线程想把所有的内容都写成1
    memset(buf,0x00,sizeof(buf));
    //初始化条件变量
    pthread_mutex_init(&mutex, NULL);

    pthread_t tid[2];
    pthread_create(&tid[0],NULL,thr1,NULL);
    pthread_create(&tid[1],NULL,thr2,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);
    printf("buf is %s\n",buf);
    //释放条件变量
    pthread_mutex_destory(&mutex);
    return 0;
}

 

 

 

条件变量解决生产着消费者模型

 

一个生产者一个消费者时

用链表存储数据

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

int beginnum = 1000;

//初始化mutex
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
//初始化条件变量
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

typedef struct _ProdInfo{
	int num;
	struct _ProdInfo *next;
}ProdInfo;

ProdInfo *HEAD = NULL;

void *thr_producer(void *arg){
	//负责向链表添加数据
	while(1){
		ProdInfo *prod=malloc(sizeof(ProdInfo));
		prod->num=beginnum++;
		//上锁
		pthread_mutex_lock(&mutex);
		//add to list
		prod->next=HEAD;
		HEAD=prod;
		printf("--------%s--------seld=%lu------------%d\n",__FUNCTION__,pthread_self(), prod->num);
		pthread_mutex_unlock(&mutex);
		//发起通知
		pthread_cond_signal(&cond);
		sleep(rand()%4);
	}
	return NULL;
}

void *thr_customer(void *arg){
	ProdInfo *prod=NULL;
	while(1){
		//取链表的数据
		pthread_mutex_lock(&mutex);
		//判断有没有数据
		if(HEAD==NULL){
			//发送消息等待
			pthread_cond_wait(&cond, &mutex);
		}
		//此时链表非空
		prod=HEAD;
		HEAD=HEAD->next;
		printf("--------%s--------seld=%lu------------%d\n",__FUNCTION__,pthread_self(), prod->num);
		//解锁
		pthread_mutex_unlock(&mutex);
		sleep(rand()%4);
		free(prod);
	}
	return NULL;
}



int main(){
	pthread_t tid[2];
	pthread_create(&tid[0], NULL, thr_producer, NULL);	
	pthread_create(&tid[1], NULL, thr_customer, NULL);
	
	pthread_join(tid[0], NULL);
	pthread_join(tid[1], NULL);
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	return 0;
}

 

 

一个生产者多个消费者时

把thr_customer中的

if(HEAD==NULL)

改成

while(HEAD==NULL)

即可。

 

 

 

信号量

加强版的互斥锁。适于多个资源多个线程访问的情况。

 

 

初始化

  • sem 定义的信号量，传出
  • pshared 非0则代表进程信号量， 0代表线程信号量
  • value 定义信号量的并发数（钥匙的个数）

 

摧毁信号量

 

申请信号量，申请成功，则value--

 

释放信号量 value++

 

 

信号量实现生产者消费者模型

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

//blank只有多少可以放生产者生产东西的地方，xfull是消费者可以消费的东西的数量
sem_t blank,xfull;
#define _SEM_CNT_  5
// 模拟饼筐
int queue[_SEM_CNT_];
int beginnum = 100;

void *thr_producter(void *arg) {
    int i = 0;
    while(1){
        //申请资源 blank--
        //看看能不能生产，还有没有空间
        sem_wait(&blank);
        //打印函数名、线程名、数量
        printf("-----%s-----self--%lu----num----%d\n",__FUNCTION__,pthread_self(),beginnum);
        //生产数据
        queue[(i++)%_SEM_CNT_] = beginnum++;
        //xfull ++
        sem_post(&xfull);
        sleep(rand()%3);
    }
    return NULL;
}

void *thr_customer(void *arg) {
    int i = 0;
    int num = 0;
    while(1){
        //看看能不能消费
        sem_wait(&xfull);
        //通过取余来
        num = queue[(i++)%_SEM_CNT_];
        printf("-----%s-----self--%lu----num----%d\n",__FUNCTION__,pthread_self(),num);
        //发送信号
        sem_post(&blank);
        sleep(rand()%3);
    }
    return NULL;
}


int main(){
    //线程，所有第二个参数是0， 如果是进程，则第二个参数是非0
    sem_init(&blank,0,_SEM_CNT_);
    //消费者一开始的初始化默认没有产品
    sem_init(&xfull,0,0);

    pthread_t tid[2];

    //线程没有设置属性，所有第二个参数为NULL
    pthread_create(&tid[0],NULL,thr_producter,NULL);
    pthread_create(&tid[1],NULL,thr_customer,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);

    sem_destroy(&blank);
    sem_destroy(&xfull);
    return 0;
}

 

 

 

文件锁

适合环境——当前系统中该进程只能起一个。

实现原理——当一个进程打开了这个文件，另一个进程发现文件被打开了，就无法再打开这个文件了。

文件锁——读共享，写独占

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

#define _FILE_NAME_ "/home/itheima/temp.lock"

int main() {
    int fd = open(_FILE_NAME_,O_RDWR|O_CREAT,0666);
    if(fd < 0){
        //文件打开失败
        perror("open err");
        return -1;
    }
    struct flock lk;
    lk.l_type = F_WRLCK;
    lk.l_whence =SEEK_SET ;
    lk.l_start = 0;
    lk.l_len  =0;

    if(fcntl(fd,F_SETLK,&lk) < 0){
        perror("get lock err");
        exit(1);
    }
    // 核心逻辑
    while(1){
        printf("I am alive!\n");
        sleep(1);
    }
    return 0;
}

 

 

 

 

哲学家用餐问题

 

王小闹儿
关注
专栏目录
JAVA 多线程之信号量(Semaphore)实例详解
08-31
主要介绍了JAVA 多线程之信号量(Semaphore)实例详解的相关资料,需要的朋友可以参考下
多线程中的信号量
fuchangyaocool的博客
07-31 2106
信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作。信号量不一定是锁定某一个资源，而是流程上的概念，比如：有 A，B 两个线程，B 线程要等 A 线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。 信号量（信号灯）与互斥锁和条件变量的主要不同在于” 灯” 的概念，灯亮则意味着资源可用，灯灭则意味着不可用。信号量主要阻塞线程，不能完全保证线程安全，如果要保证线程安全，需要信号量和互斥锁一起使..
多线程——信号量、条件变量、互斥量互斥锁
qq_44423388的博客
11-05 3432
信号量是所有原语里面功能最强大的。它不光是一个通信原语，还是一个同步原语。 多线程——信号量、条件变量、互斥量互斥锁
多线程与信号量
qq_42152365的博客
11-16 6679
多线程与信号量 我们的目标是快乐地学习计算机！O(∩_∩)O~   【信号量】 虽然它叫信号，其实从算法理解上和信号没啥关系。更好的理解是用于进程之间通信“我要运行，你不要运行”的变量。 信号量为0(≤0)表示“别动”，信号量是非0（&gt;0）表示“可以动”   【操作】 信号量只有三个操作： ① 赋予一个初始值 （init） ② 判断是不是0，如果是0，挂起，如果是正数，信...
多线程 --- 信号量
m0_62229058的博客
02-27 707
参数解释：sem_t 是 POSIX 标准中定义的信号量类型。pshared： 值为0时，该信号量将被线程共享；值为非0时，该信号量将被进程共享。value： 表示信号量的初始值。返回值：成功，返回0；失败，返回相应的错误码 (errno)。
mutexes-variables-semaphores.rar_linux 线程锁_mutexes_锁和信号量
09-20
在Linux系统中，多线程编程是实现并发执行的关键技术，而互斥锁（mutexes）、条件变量（condition variables）和信号量（semaphores）是确保线程安全和资源同步的重要工具。以下是对这些概念的详细解释： 1. 互斥锁...
C语言信号量同步与互斥生产者消费者互斥锁读写者问题哲学家就餐问题课程设计
04-20
C语言信号量同步与互斥生产者消费者互斥锁读写者问题哲学家就餐问题课程设计 本课程设计旨在通过C语言编程来解决信号量机制下的同步、互斥、生产者消费者问题、哲学家就餐问题和读写者问题。 一、信号量机制 信号...
linux之线程同步一.doc
05-01
本文旨在深入探讨Linux中线程同步的几种常见方法及其应用场景，包括互斥锁（mutexes）、信号量（semaphores）以及条件变量（condition variables），同时还会简要提及读写锁和自旋锁。 #### 二、互斥锁（Mutexes） ...
file_dw.rar_多线程 读写_文件 系统 dw
09-14
3. **同步原语**：如互斥锁（Mutex）、信号量（Semaphore）和条件变量（Condition Variable），它们用于控制线程的执行顺序和资源访问，防止竞态条件。 4. **死锁**：当两个或更多线程互相等待对方释放资源而无法...
linuxduoxiancheng.rar_Linux下 线程_linux 多线程_linux多线程
09-20
在提供的文件“linux 多线程编程.txt”中，可能包含了更详细的Linux多线程编程实例和技巧，包括如何使用上述的同步机制，可以作为学习和实践的参考。而“www.pudn.com.txt”可能是另一个资料来源，可能包含了更多...
多线程之信号量
qq_33374294的博客
06-10 588
本文的信号量类型为POSIX无名信号量 1、信号量基础知识 我们通常写程序时会定义的一个变量flag,然后用if判断，当flag为1时执行，flag为0时不执行某段程序，而信号量sem的作用便是
读写锁
csq653273717的博客
10-06 516
1、概述 　　读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么是不加锁状态，而且一次只有一个线程对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可用同时占有读模式的读写锁。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的，当它以写模式锁住时，它是以独占模式锁住的
多线程与信号量简介
最新发布
qq_52484093的博客
05-04 683
第 53 行，get_shared_memory() 函数调用了 shmget() 函数，shmget() 是一个Linux系统调用函数，用于创建一个新的共享内存段（segment）或获取一个已存在的共享内存段。子线程读完以后，信号量 w 的值会加一，主线程才能去写；由于信号量的初始值为 1，所以只能有一个子线程获取到信号量，其它的线程来获取信号量时，发现信号量的值为 0，就会阻塞等待信号量被释放。该程序中使用的两个信号量，信号量 w 和信号量 r，信号量 w 的初始值为 1，信号量 r 的初始值为 0。
使用读写锁实现线程同步
aiduan6474的博客
09-23 248
简介： 读写锁与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。 读写锁特性: 读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。 读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功。如果线程以写模式加锁会阻塞。 读写锁是“读模式加锁”时，如果有另外线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求，这样可以避免读模式锁长期占用，而等待...
java信号量_JAVA多线程--信号量(Semaphore)
weixin_42117037的博客
02-12 1506
简介信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对...
多线程（11）多线程同步之信号量（Linux实现）
哈尼的博客
02-27 1889
多线程（11）多线程同步之信号量（Linux实现）
Linux多线程——使用信号量同步线程
haierboos
09-01 814
信号量、同步这些名词在进程间通信时就已经说过，在这里它们的意思是相同的，只不过是同步的对象不同而已。但是下面介绍的信号量的接口是用于线程的信号量，注意不要跟用于进程间通信的信号量混淆，关于用于进程间通信的信号量的详细介绍可以参阅我的另一篇博文：Linux进程间通信——使用信号量。相似地，线程同步是控制线程执行和访问临界区域的方法。 一、什么是信号量 线程的信号量与进程间通信中使用的信号量的...
多线程并发之Semaphore(信号量)使用详解
热门推荐
小小默：进无止境
01-02 3万+
专题相关文章： 从内存可见性看Volatile、原子变量和CAS算法 多线程并发之CountDownLatch(闭锁)使用详解 多线程并发之显示锁Lock与其通信方式Condition源码解读 多线程并发之读写锁(ReentranReadWriteLock&amp;amp;amp;amp;ReadWriteLock)使用详解 多线程并发之线程池Executor与Fork/Join框架 多线程并发之JUC 中的 Atomi...
多线程编程：同步对象深度解析
本文主要探讨了五种同步机制：互斥锁、条件变量、多读单写锁、信号量以及进程间同步，并比较了各种同步原语。同步对象是存储在内存中的变量，可以被不同进程内的线程共享，即使它们相互不可见。这些同步变量可以在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值