Linux线程浅析[线程的同步和互斥之线程互斥锁]

最新推荐文章于 2022-06-19 15:47:10 发布
最新推荐文章于 2022-06-19 15:47:10 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： # 2：LinuxC学习 # 1：C语言之美 文章标签： linux 线程 线程互斥 互斥锁 同步并发
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_29924041/article/details/67088941
版权

Linux线程浅析[线程的同步和互斥]

  1. 线程同步
  2. 线程互斥
  3. 线程互斥的相关函数
  4. 线程同步的相关函数

线程同步

是宏观上的一个概念，在微观上面包含线程的相互排斥和线程的执行顺序的约束问题
解决方法：
    条件变量
    线程信号量

例子：一栋大楼的建造，包含了质监局的检验和工程队的施工，那么假设质监局和工程队是两个线程，而大楼则为共享资源，首先相互排斥的原则为工程队施工的时候，质监局是不能进行检验的，因为这个时候大楼还没有建好，而质监局的检验依赖于工程队施工的结果，所以质监局必须等待工程队将大楼建造好．所以后一个线程依赖于前一个线程对共享资源操作的结果．所以说线程同步是包含了相互排斥和线程的执行顺序．

线程互斥

线程的相互排斥
解决方法：
    互斥锁
    读写锁
    线程信号量

　例子：
　一个公用厕所，假设只有一个坑，那么很多人去上厕所的时候，后一个就必须等后一个上完厕所之后才能上厕所．所以同一时间只能有一个人上厕所．这就是互斥．其实在生活中有很多例子．如银行账户的操作问题．１２３０６的售票问题等．都是互斥
　注意：同步包含了互斥，互斥仅仅只是相互排斥，而同步是互斥加顺序

　先来一段有问题的代码：两个线程同时去访问同一个账户的问题：
　 account.h

/*
 * ===========================================================================
 *
 *       Filename:  account.h
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月28日 22时04分18秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#ifndef __ACCOUNT_H_
#define __ACCOUNT_H_
//声明银行账户的结构体
  typedef struct{
    int code;
    double balance;
  }Account;

//创建银行账户
extern Account* create_account(int code,double balance);

//销毁一个账户
extern void destory_account(Account* account);

//存款
extern double withdraw(Account* account,double amt);

//取款
extern double deposit(Account* a,double amt);

//查看账户余额
extern double get_balance(Account* account);

#endif

account.c

/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21时16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>
/* 
 *创建一个账户
 *返回这个账户的指针
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化锁的过程
    return account;
}
/* *
 *销毁一个账户
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
}

/* *
 *取款，返回的是账户的余额
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  if(amt < 0 || amt > account->balance){
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是账户的余额
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   if(amt < 0){
      return 0.0;
   }
   int result = account ->balance + amt;
   sleep(2);
   account->balance = result;
   return result;
}

/* *
 *获取的就是这个账户的余额
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}

accountTest.c

/*
 * ===========================================================================
 *
 *       Filename:  accountTest.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21时31分19秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include"account.h"

typedef struct{
  char name[20];
  Account* account;
  double amt;
}ArgvType;

/* *
 *检查账户的函数
 * */
void* th_check(void *argv){
  ArgvType* argvType = (void*)argv;
  double balance = get_balance(argvType->account);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *取款函数
 * */
void* th_withdraw(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = withdraw(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *存款函数
 * */
void* th_deposite(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = deposit(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

int main(int argc,char *argv[]){
  int result;
  pthread_t boyfriend,girlfriend;
  Account *account = create_account(10001,10000);
  ArgvType argv_typeboy,argv_typegirl;
  strcpy(argv_typeboy.name,"zhangsan");
  strcpy(argv_typegirl.name,"xiaoli");
  argv_typeboy.account = account;
  argv_typegirl.account = account;
  argv_typeboy.amt = 10000;
  argv_typegirl.amt = 10000;

  if((result = pthread_create(&boyfriend,NULL,th_withdraw,(void*)&argv_typeboy))!=0){
     perror("boythread create error");
     exit(EXIT_FAILURE);
  }
  if((result = pthread_create(&girlfriend,NULL,th_withdraw,(void*)&argv_typegirl))!=0){
    perror("girlthread create error");
    exit(EXIT_FAILURE);
  }

  pthread_join(boyfriend,NULL);
  pthread_join(girlfriend,NULL);
  printf("get_balance:%f\n",get_balance(account));
  printf("thread:%lx exe ended\n",pthread_self());



  return 0;
}

name:zhangsan,withdraw:10000.000000,balance:0.000000,pthread:7f34bf2a9700
name:xiaoli,withdraw:10000.000000,balance:0.000000,pthread:7f34beaa8700
get_balance:0.000000
thread:7f34bfa94740 exe ended

　输出的结果如下所示：
　从上面输出结果中我们可以看到，其实ｘｉａｏｌｉ和ｚｈａｎｇｓａｎ都取到了１００００，但是这中情况是及其不符合日常生活的逻辑的，而我们的线程互斥的目的也就是为了解决这样一种并发，即多个线程访问同一个共享资源的时候，怎么去进行处理，后面在此例子基础上面去做修改．

线程互斥的相关函数

互斥锁：

互斥锁是一种简单的加锁的方法来控制对共享资源的访问。在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源的访问，若其他线程希望上锁一个已经被上了锁的资源，则该线程挂起，知道上锁的线程释放互斥锁为止；

互斥锁数据类型：pthread_mutex_t

#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *mutexattr);//初始化互斥锁
int pthread_mutex_destory(pthread_mutex_t * mutex);
／／销毁互斥锁
返回：成功返回0,失败返回错误编号
参数：
    mutex:互斥锁
    mutexattr：互斥锁创建方式
        PTHREAD_MUTEX_INITIALIZER:创建快速互斥锁
        PTHREAD_RECERSIVE_MUTEX_INITIALIZER_NP:创建递归互斥锁
        PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP:创建检错互斥锁

互斥锁的加锁和释放锁的过程

#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex)
功能:上锁，拿不到锁的时候阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex)
功能：拿不到锁返回出错信息
int pthread_mutex_unlock(pthread_mutex_t *mutex)
功能：释放锁
返回：成功返回0,错误返回错误码
参数：mutex
一个共享资源绑定一把锁，
建议：定义在结构体中，尽量不设置成为全局变量，否则可能会出现一把锁去锁几百个账户，导致并发性的下降：
临界区：对共享资源进行加锁到释放锁的整个代码区域（从上锁开始到释放锁结束）

互斥锁的属性创建和销毁;

    #include<pthread.h>
    int pthread_mutexattr_init(pthread_mutexattr_t *attr);
    int pthread_mutexattr_destory(pthead_muteattr_t *attr);
    返回值：成功返回0,失败返回错误码

参数：
    attr:互斥锁属性

互斥锁的进程共享属性：

#include<pthread.h>

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr,int *restrict　pshared)
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,int pshared)
返回：成功返回0,失败返回错误编号
参数：
    attr：互斥锁属性
    pshared：进程共享属性
    PTHREAD_PROCESS_PRIVATE(默认)
        锁只能用于一个进程内部的两个线程进行互斥
    PTHREAD_PROCESS_SHARED
        锁能够用于两个不同进程中的线程进行互斥(跨进程)

一般情况下我们都是在同一个进程中去使用互斥锁

互斥锁的类型：

#include<pthread.h>
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr,int *restrict type)
int pthreａd_mutexattr_settype(pthread_amutexattr_t *attr,int type)
参数
    attr 互斥锁属性
    type:互斥锁类型
        标准互斥锁：PTHREAD_MUTEX_NOMAL
            第一次上锁成功，第二次上锁失败
        递归互斥锁：PTHREAD_MUTEX_RECURSIVE
            第一次上锁成功，第二次上锁还是成功，内部计数
        检错互斥锁：PTHREAD_MUTEX_ERRORCHECK
            第一次上锁成功，第二次上错会出错
默认互斥锁：PTHREAD_MUTEX_DEFAULT(同标准互斥锁)

　先上一个简单的上锁的案例：，在上述基础上修改的

/*
 * ===========================================================================
 *
 *       Filename:  account.h
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月28日 22时04分18秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#ifndef __ACCOUNT_H_
#define __ACCOUNT_H_
//声明银行账户的结构体
//引用ｐｔｈｒｅａｄ头文件．方便后面加锁
#include<pthread.h>
  typedef struct{
    int code;
    double balance;
    //将锁声明在结构体中，有助于每一个这样的结构体都有一把锁，那么在操作的时候，有利于优化并发效果
    pthread_mutex_t pthreadmutex;
  }Account;

//创建银行账户
extern Account* create_account(int code,double balance);

//销毁一个账户
extern void destory_account(Account* account);

//存款
extern double withdraw(Account* account,double amt);

//取款
extern double deposit(Account* a,double amt);

//查看账户余额
extern double get_balance(Account* account);

#endif
/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21时16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>
/* 
 *创建一个账户
 *返回这个账户的指针
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化锁的过程
    pthread_mutex_init(&account->pthreadmutex,NULL);
    return account;
}
/* *
 *销毁一个账户
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
   //销毁锁的过程
   pthread_mutex_destroy(&account->pthreadmutex);
}

/* *
 *取款，返回的是账户的余额
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  //上锁的过程
  pthread_mutex_lock(&account->pthreadmutex);
  if(amt < 0 || amt > account->balance){
    //解锁的过程
    pthread_mutex_unlock(&account->pthreadmutex);
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //解锁的过程
  pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是账户的余额
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   //上锁的过程
   pthread_mutex_lock(&account->pthreadmutex);
   if(amt < 0){
     //解锁的过程
    pthread_mutex_unlock(&account->pthreadmutex);
      return 0.0;
   }
   int balance = account ->balance;
   sleep(2);
   int result = balance + amt;
   account->balance = result;
   //解锁的过程
   pthread_mutex_unlock(&account->pthreadmutex);
   return result;
}

/* *
 *获取的就是这个账户的余额
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}
/*
 * ===========================================================================
 *
 *       Filename:  accountTest.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21时31分19秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include"account.h"

typedef struct{
  char name[20];
  Account* account;
  double amt;
}ArgvType;

/* *
 *检查账户的函数
 * */
void* th_check(void *argv){
  ArgvType* argvType = (void*)argv;
  double balance = get_balance(argvType->account);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *取款函数
 * */
void* th_withdraw(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = withdraw(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *存款函数
 * */
void* th_deposite(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = deposit(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

int main(int argc,char *argv[]){
  int result;
  pthread_t boyfriend,girlfriend;
  Account *account = create_account(10001,10000);
  ArgvType argv_typeboy,argv_typegirl;
  strcpy(argv_typeboy.name,"zhangsan");
  strcpy(argv_typegirl.name,"xiaoli");
  argv_typeboy.account = account;
  argv_typegirl.account = account;
  argv_typeboy.amt = 10000;
  argv_typegirl.amt = 10000;

  if((result = pthread_create(&boyfriend,NULL,th_withdraw,(void*)&argv_typeboy))!=0){
     perror("boythread create error");
     exit(EXIT_FAILURE);
  }
  if((result = pthread_create(&girlfriend,NULL,th_withdraw,(void*)&argv_typegirl))!=0){
    perror("girlthread create error");
    exit(EXIT_FAILURE);
  }

  pthread_join(boyfriend,NULL);
  pthread_join(girlfriend,NULL);
  printf("get_balance:%f\n",get_balance(account));
  printf("thread:%lx exe ended\n",pthread_self());



  return 0;
}

这里写图片描述
　输出的结果如上所示，这个时候其实取款的时候就已经没有并发情况再出现了

/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21时16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>

static pthread_mutexattr_t attr;
/* 
 *创建一个账户
 *返回这个账户的指针
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化锁的过程
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
    //pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
    //pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
    //pthread_mutex_init(&account->pthreadmutex,NULL);
    pthread_mutex_init(&account->pthreadmutex,&attr);
    return account;
}
/* *
 *销毁一个账户
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
   //销毁锁的过程
   pthread_mutexattr_destroy(&attr);
   pthread_mutex_destroy(&account->pthreadmutex);
}

/* *
 *取款，返回的是账户的余额
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  //上锁的过程
  pthread_mutex_lock(&account->pthreadmutex);
  if(amt < 0 || amt > account->balance){
    //解锁的过程
    pthread_mutex_unlock(&account->pthreadmutex);
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //解锁的过程
  pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是账户的余额
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   //上锁的过程
   pthread_mutex_lock(&account->pthreadmutex);
   if(amt < 0){
     //解锁的过程
    pthread_mutex_unlock(&account->pthreadmutex);
      return 0.0;
   }
   int balance = account ->balance;
   sleep(2);
   int result = balance + amt;
   account->balance = result;
   //解锁的过程
   pthread_mutex_unlock(&account->pthreadmutex);
   return result;
}

/* *
 *获取的就是这个账户的余额
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}

　以上都是对ｃ的ｐｔｈｒｅａｄ互斥锁做的一个相对比较简单的一些使用方法．有兴趣的可以ｃｏｐｙ下来ｒｕｎ一下，因为我也是新手，写的不好的地方欢迎指出

欢迎持续访问博客

^_^ 小小码nong
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程（二）互斥锁详解
liuming
05-22 3500
本文对互斥锁的定义原理及使用进行详细的描述
标准库pthread_mutex_t互斥锁和glib锁
02-07 521
标准库pthread_mutex_t互斥锁和glib锁
Linux系统编程----16（线程同步，互斥量 mutex,互斥锁的相关函数，死锁，读写锁）
LXY的博客
09-05 370
同步概念 所谓同步，即同时起步，协调一致。不同的对象，对“同步”的理解方式略有不同。如，设备同步，是指在两 个设备之间规定一个共同的时间参考；数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持 一致；文件同步，是指让两个或多个文件夹里的文件保持一致。等等 而，编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相 配合。主旨在协同步调，按预定的...
线程的互斥锁
weixin_30460489的博客
09-21 110
一、竞争与同步 当多个线程同时访问其所共享的进程资源时，需要相互协调，以防止出现数据不一致、不完整的问题。这就叫线程同步。 二、互斥量 int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr); 功能：初始化互斥量 //亦可 pthread_mutex_t mutex = PTHR...
Linux系统开发 | 线程同步与互斥
本末实验室
08-01 1895
拥有梦想是一种智力，实现梦想是一种能力。 概述 线程共享同一进程的地址空间，线程间通过全局变量交换数据进行通信。为了避免多个进程同时访问同一个共享资源而引发冲突，多个线程访问共享数据时需要同步或互斥机制 同步机制：指的是多个任务按照约定的先后次序相互配合完成一件事情 互斥机制：一次只允许一个任务(进程、线程)访问的共享资源 同步机制 信号量：代表某一类资源，其值表示...
linux线程间的同步与互斥知识点总结
09-14
总结来说，线程同步和互斥是保证多线程程序正确性的关键。条件变量提供了灵活的同步机制，允许线程在满足特定条件时才继续执行，而互斥锁则确保了对临界资源的独占访问。理解并熟练运用这些机制，开发者可以在编写多...
Linux线程同步之互斥量（mutex）
01-09
互斥量（也称为互斥锁）出自POSIX线程标准，可以用来同步同一进程中的各个线程。当然如果一个互斥量存放在多个进程共享的某个内存区中，那么还可以通过互斥量来进行进程间的同步。 　互斥量，从字面上可以知道是...
浅析Linux下一个简单的多线程互斥锁的例子
09-15
为了确保多个线程在共享资源时的正确性，我们需要引入同步机制，其中互斥锁（Mutex）是一种常用的方法。本文将通过一个简单的例子来深入浅出地解析Linux环境下多线程互斥锁的工作原理及其应用。 首先，让我们了解...
Linux下多线程编程的互斥与同步
07-31
本文将说明如何使用信号量实现线程之间的互斥与同步。互斥锁只有0，1两中状态，适合于线程对共享资源的独占访问，很多时候每个资源可以同时被有限的线程访问，此时互斥锁将无法满足；条件变量同步也同样存在这种问题...
Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）
君子性非异
10-10 2万+
本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量、信号量和读写锁。  下面是思维导图： 简介 进程— 资源分配的最小单位 线程— 程序执行的最小单位 进程是一个程序的一个实例，拥有自...
linux线程互斥与同步（part1）—互斥锁（mutex）的原理及其实现机制
My Coding Life
05-25 1万+
一段代码引发的问题首先，我们来编写一段代码，它的目的是定义一个全局变量，创建两个线程对其进行5000++的操作。运行结果如下： 当然，目前来看，这段程序并没有任何的问题。然而，对于此程序，结合线程的特点，我们需要明确两点： 局部变量 i 不是共享的，因为它在栈中 gCount是共享的，因为它是全局变量，属于代码段。 我们知道，只要是共享的资源，那么它就可以看作临界资源，而临界资源的访问需要同步与互
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 7万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
C++ 线程同步之互斥锁
喜欢打篮球的普通人
06-19 5906
进行多线程编程，如果多个线程需要对同一块内存进行操作，比如：同时读、同时写、同时读写，对于后两种情况来说，如果不做任何的人为干涉就会出现各种各样的错误数据。解决多线程数据混乱的方案就是进行线程同步，最常用的就是互斥锁，在 C++11 中一共提供了四种互斥锁：不论是在 C 还是 C++ 中，进行线程同步的处理流程基本上是一致的，C++ 的 mutex 类提供了相关的 API 函数：成员函数 独占互斥锁对象有两种状态：锁定和未锁定。 除了使用 lock() 还可以使用 try_lock() 获取互斥锁
linux线程互斥与同步---互斥锁
07-08 1097
由于线程是共享进程的资源和空间的，所以对这些资源进行操作时，必须考虑到线程间资源访问的同步与互斥问题，这里主要说的是POSIX中的两种线程同步机制，分别为互斥锁和信号量，这两种同步机制能够互相调用对方来实现，但互斥锁使用与同时可用的资源是唯一的情况，信号量更适用于同时可用的资源为多个的情况。 互斥锁：是一种简单的加锁方法来控制对共享资源的原子操作，这个互斥锁只有两种状态：上锁，解锁，可以把互斥锁
Linux线程同步-互斥锁
qq_24429681的博客
08-30 178
这是学习C语言中文网的笔记 简介 互斥锁（Mutex）又称互斥量或者互斥体，是最简单也最有效地一种线程同步机制。互斥锁的用法和实际生活中的锁非常类似，当一个线程访问公共资源时，会及时地“锁上”该资源，阻止其它线程访问；访问结束后再进行“解锁”操作，将该资源让给其它线程访问。 函数声明 pthread_mutex_t lock; /* 实例化互斥锁结构体 */ pthread_mutex_init(&lock, NULL); /* 动态初始化， 成功返回0，失败返回非0 */ pthread_mute
进程间同步（1）——条件变量和互斥量
weixin_30528371的博客
08-01 103
1. 概述 条件变量和互斥量是最基本的同步形式，总是用于同步同一个进程的各个线程间同步。 当把条件变量或互斥量放在共享内存区时，可用于进程间同步。 同样的情况还有读写锁，它们都是随进程的持续性。 2.互斥锁 互斥锁指代相互排斥，用于保护临界区。多个线程和多个进程分享的共享数据。 静态初始化：static pthread_mutex_t lock = PTHREAD_MUTEX_I...
linux线程同步之互斥锁mutex
野生猿-群号1025127672
07-07 660
互斥锁的意义和使用方法较为简单，有点类似于原子操作。先把常用的几个线程互斥锁相关的api列出，再一个个详细介绍：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict at...
线程及进程同步方法分享（一）： 线程同步（互斥量）
wys的专栏
02-02 345
互斥量的相关API: //int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); //int pthread_mutex_destroy (pthread_mutex_t *mutex); //int pthread_mutex_trylock (pthread_mutex_t *...
Linux — 浅析线程以及多线程的同步与互斥
阿亮的博客
06-04 2526
线程 链接：http://blog.csdn.net/ctthuangcheng/article/details/8914712 关于linux线程 在许多经典的操作系统教科书中, 总是把进程定义为程序的执行实例, 它并不执行什么, 只是维护应用程序所需的各种资源. 而线程则是真正的执行实体. 为了让进程完成一定的工作, 进程必须至少包含一个线程. 如
Linux线程同步之互斥量加锁解锁
最新发布
05-17
在 Linux 系统中，多个线程同时访问共享资源可能会导致数据竞争问题，为了避免这种情况，我们需要使用线程同步机制。其中，互斥量（mutex）是一种常见的线程同步工具，用于保护共享资源的访问。 互斥量的使用需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值