90-互斥量的共享属性

最新推荐文章于 2023-12-23 22:09:07 发布
最新推荐文章于 2023-12-23 22:09:07 发布
阅读量1.8k 收藏 2
点赞数 4
分类专栏： linux 编程学习笔记 Linux 环境编程修炼指南-外功心法 文章标签： 互斥量属性 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1007729991/article/details/62235932
版权

用于线程互斥的互斥量也有相应的属性 pthread_mutexattr_t，这里只讨论三个方面：

  • 共享属性
  • 鲁棒属性
  • 互斥量的递归类型

本文先介绍共享属性。

1. 属性的初始化与回收

互斥量属性的数据类型是 pthread_mutexattr_t. 下面两个函数分别用于互斥量属性的初始化与回收。

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

2. 共享属性

除了互斥量有共享属性外，其它的线程互斥同步对象如读写锁、自旋锁、条件变量、屏障都有共享属性。

该属性有两种情况：

  • PTHREAD_PROCESS_PRIVATE : 这种是默认的情况，表示互斥量只能在本进程内部使用。
  • PTHREAD_PROCESS_SHARED：表示互斥量可以在不同进程间使用。

对于第一种情况，我们早已经学会。第二种情况，需要结合前面的进程间通信技术才有用。一般需要在共享内存中分配互斥量，然后再为互斥量指定PTHREAD_PROCESS_SHARED属性就可以了。

3. 实验

本实验中的程序分为了 4 个部分，分别是 init、destroy、buyticket 和 rbstbuyticket.

init 程序的作用是申请共享内存，并在共享内存中分配互斥量等。
destroy 用来回收共享内存中的互斥量，并销毁共享内存。
buyticket 和 rbstbuyticket 是从共享内存的数据中抢票的。

.
|- init.c
|- destroy.c
|- buyticket.c
|- rbstbuyticket.c
|- Makefile // Makefile 文件主要用来一次性编译完所有文件。

本部分实验，只用的到前三个程序，最后一个 rbstbuyticket.c 在讲鲁棒属性的时候用的到。

3.1 init.c 程序

程序 init 用来创建一块共享内存，可以给 init 程序传递一个命令行参数，也可以不传。如果传递参数，表示为互斥量指定鲁棒性属性，本文我们先不传递参数。

// init.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>

#define PERR(msg) do { perror(msg); exit(-1); } while(0)
#define PPERR(err, msg) do { err = errno; perror(msg); exit(-1); } while(0)

struct ticket {
  int remain;
  pthread_mutex_t lock;
};

// 打印共享属性
void printshared(pthread_mutexattr_t *attr) {
  int err, shared;
  err = pthread_mutexattr_getpshared(attr, &shared);
  if (err != 0) PPERR(err, "pthread_mutexattr_getshared");
  if (shared == PTHREAD_PROCESS_PRIVATE)
    puts("shared = PTHREAD_PROCESS_PRIVATE");
  else if (shared == PTHREAD_PROCESS_SHARED)
    puts("shared = PTHREAD_PROCESS_SHARED");
  else
    puts("shared = ???");
}
// 打印鲁棒属性
void printrobust(pthread_mutexattr_t *attr) {
  int err, robust;
  err = pthread_mutexattr_getrobust(attr, &robust);
  if (err != 0) PPERR(err, "pthread_mutexattr_getrobust");
  if (robust == PTHREAD_MUTEX_STALLED)
    puts("robust = PTHREAD_MUTEX_STALLED");
  else if (robust == PTHREAD_MUTEX_ROBUST)
    puts("robust = PTHREAD_MUTEX_ROBUST");
  else
    puts("robust = ???");
}

int main(int argc, char* argv[]) {
  int err, shared, robust = 0, flag = 1;
  if (argc >= 2) robust = 1;
  key_t key = 0x8888;
  // 创建共享内存
  int id = shmget(key, getpagesize(), IPC_CREAT | IPC_EXCL | 0666);
  if (id < 0) PERR("shmget");

  // 挂接共享内存
  struct ticket *t = (struct ticket*)shmat(id, NULL, 0); 

  if ((int)t == -1) PERR("shmat");

  // 设置余票数量为 5
  t->remain = 5;

  pthread_mutexattr_t mutexattr;
  err = pthread_mutexattr_init(&mutexattr);
  if (err != 0) PPERR(err, "pthread_mutexattr_init");

  printshared(&mutexattr);
  printrobust(&mutexattr);

  // 将互斥量的共享属性设置为可以进程间共享使用。
  shared = PTHREAD_PROCESS_SHARED;
  err = pthread_mutexattr_setpshared(&mutexattr, shared);
  if (err != 0) PPERR(err, "pthread_mutexattr_setshared");

  // 如果有命令行参数，就将鲁棒性设置为 PTHREAD_MUTEX_ROBUST
  // 本文暂时不设置此值
  if (robust) {
    err = pthread_mutexattr_setrobust(&mutexattr, PTHREAD_MUTEX_ROBUST);
    if (err != 0) PPERR(err, "pthread_mutexattr_setshared");
  }

  puts("modify attribute ------------------>");
  printshared(&mutexattr);
  printrobust(&mutexattr);

  pthread_mutex_init(&t->lock, &mutexattr);

  err = pthread_mutexattr_destroy(&mutexattr);
  if (err != 0) PPERR(err, "pthread_mutexattr_destroy");

  err = shmdt((void*)t);

  if (err != 0) PERR("shmdt");

  return 0;
}

3.2 destroy.c

destroy 程序主要用于回收互斥量和共享内存。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>

#define PERR(msg) do { perror(msg); exit(-1); } while(0)
#define PPERR(err, msg) do { err = errno; perror(msg); exit(-1); } while(0)

struct ticket {
  int remain;
  pthread_mutex_t lock;
};

int main() {
  int err;
  key_t key = 0x8888;
  int id = shmget(key, 0, 0); 
  if (id < 0) PERR("shmget");

  struct ticket *t = (struct ticket*)shmat(id, NULL, 0); 

  if ((int)t == -1) PERR("shmat");

  err = pthread_mutex_destroy(&t->lock);
  if (err != 0) PPERR(err, "pthread_mutex_destroy");

  err = shmdt((void*)t);
  if (err != 0) PERR("shmdt");

  err = shmctl(id, IPC_RMID, NULL);
  if (err != 0) PERR("shmctl");


  return 0;
}

3.3 buyticket.c

buyticket 程序主要用于抢票，该程序需要从命令行传递参数，表示抢票人的名字。比如./buyticket allen 表示抢票人是 allen.

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>

#define PERR(msg) do { perror(msg); exit(-1); } while(0)
#define PPERR(err, msg) do { err = errno; perror(msg); exit(-1); } while(0)

struct ticket {
  int remain;
  pthread_mutex_t lock;
};

int main(int argc, char* argv[]) {
  if (argc < 2) {
    printf("Usage: %s <name>\n", argv[0]);
    exit(-1);
  }

  char *name = argv[1];
  int err, shared, flag = 1;
  key_t key = 0x8888;
  int id = shmget(key, 0, 0); 
  if (id < 0) PERR("shmget");

  struct ticket *t = (struct ticket*)shmat(id, NULL, 0); 

  if ((int)t == -1) PERR("shmat");

  // 只要票数大于 0 就不断抢票。
  while(flag) {
    pthread_mutex_lock(&t->lock);
    int remain = t->remain;
    if (remain > 0) {
      sleep(1);
      printf("%s buy a ticket\n", name);
      --remain;
      sleep(3);
      t->remain = remain;
    }   
    else flag = 0;
    pthread_mutex_unlock(&t->lock);
    sleep(2);
  }

  err = shmdt((void*)t);
  if (err != 0) PERR("shmdt");

  return 0;
}

3.4 编译——Makefile 文件

此文件可以方便程序编译。

main:init destroy buyticket
init:init.c
  gcc init.c -o init -lpthread
destroy:destroy.c
  gcc destroy.c -o destroy -lpthread
buyticket:buyticket.c
  gcc buyticket.c -o buyticket -lpthread

注意，上面所有以 gcc 开头的行前面是个 tab 符号，即按下键盘上的 Tab 键所产生的，千万不能是空格。

完成些文件后，保存退出，然后在命令行键入

$ make

此时就会产生三个程序：init、destroy 和 buyticket

3.5 运行

  • 初始化
./init
  • 开启两个进程进行抢票

开启两个终端假设为终端 A 和终端 B. 在终端 A 中键入

./buyticket allen

终端 B 中键入

./buyticket luffy

记住这两个进程在执行时间上不能差的太远，别等到其中一个运行结束才开始另一个。

  • 运行结果


这里写图片描述
图1 运行结果

可以从图 1 中看到，一共有 5 张票，分别被两个不同进程中的线程所抢到，其中 allen 抢了 3 张票，而 luffy 抢了 2 张票。

完成了上面的程序的执行后，别忘记使用 ./destroy 对共享内存进行回收。

4. 总结

  • 掌握互斥量的共享属性
  • 掌握共享内存的使用

练习：上面的程序中，当 allen 抢到第 2 张票后，立即按下 CTRL + C 中断进程，会有什么后果？

--Allen--
关注
专栏目录
系统线程-多线程2-互斥量、信号量、条件变量
m0_71813740的博客
08-29 1051
- linux系统中提供了两个信号量实现，一种是System V信号量，另一种是POSIX信号量，它们的作用是相同的，都是用于同步进程之间及线程之间的操作，以达到无冲突地访问共享资源的目的。-- 这里注册函数就有了意义，如果在上锁完，还没有进行解锁，线程就结束的话，可以利用注册函数，在注册函数中写解锁的操作，这样就算线程结束，锁也会被解锁。2、某些线程运行后，有时需要等待一定的条件才会继续执行，如果条件不满足就会等待，而条件的达成， 很可能取决于另一个线程。-- 条件变量主要是解决上面的第二个问题。
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
Boss_peng的博客
06-05 493
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
共享互斥量
weixin_30848775的博客
05-29 169
共享互斥变量shared_mutex允许线程获取多个共享所有权和一个专享所有权，即多个读进程一个写进程。读锁定时使用boost::shared_lock<boost::shared_mutex>，写锁定时使用boost::unique_lock<boost::shared_mutex>。 #include <boost/thread.hpp> #i...
互斥量属性
weixin_38451161的博客
04-18 409
四、互斥锁属性 线程和线程的同步对象（互斥量，读写锁，条件变量）都具有属性。在修改属性前都需要对该结构进行初始化。使用后要把该结构回收。我们用pthread_ mutexattr_init函数对pthread_mutexattr结构进行初始化，用pthread_mutexattr_destroy函数对该结构进行回收。 4 名称:： pthread_mutexattr_init/pthread_mutexattr_destroy 功能： ...
【Linux】互斥量属性
萧十一的技术小站
03-01 629
1.属性类型：pthread_mutexattr_t 该类型是一个结构，其中存放了互斥量的各属性字段。在对互斥量初始化时，可以使用PTHREAD_MUTEX_INITIALIZER常量初始化，或在互斥量的初始化函数中的属性参数传递空指针。这样得到互斥量为默认属性。 2.初始化与反始化 对于非默认属性，可使用如下的函数对pthread_mutexattr_t结构进行初始化和反初始化。初始化后的...
Linux线程互斥量--进程共享属性
kunpengku
06-09 2181
多线程中，在互斥量和 读写锁的 属性中，都有一个叫 进程共享属性 。对于互斥量，查询和设置这个属性的方法为： pthread_mutexattr_getpshared pthread_mutexattr_setpshared我一开始不理解什么是 进程共享属性。 看了man中的说明如下The pthread_mutexattr_getpshared() function shall obtai
使用互斥锁（Mutex）管理共享资源
最新发布
csjds的专栏
12-23 854
在本文中，我们将探讨互斥锁在管理共享资源中的作用，以及在并发编程中使用它的必要性。
互斥量mutex的简单使用(实例讲解)
09-04
参数`mutex`是要初始化的互斥量的指针，`attr`通常设置为NULL，表示使用默认属性。如果成功，该函数将返回0；否则，返回错误码。 ```c int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_...
Pthread - 互斥量（Mutex） 和 条件变量（Condition variable）
u010090316的博客
05-03 2265
Pthread - 互斥量（Mutex） 和 条件变量（Condition variable）MutexMutex 全称 “mutual exclusion”，是一种实现线程同步的方法。 在访问共享资源时，Mutex 的作用如同一把“锁”。给定时间只有一个线程可以对 Mutex 加锁，其他线程必须等待当前线程解锁才能重新获取 Mutex。如此线程便可以依次访问共享资源。 通常Mutex 使用场景
HarmonyOS IoT设备内核编程接口-----互斥锁
m0_46455623的博客
03-10 4632
HarmonyOS Iot设备内核变成接口---互斥锁讲解使用
数据共享之互斥量mutex
KangRoger的专栏
10-13 7269
在看《Cplusplus Concurrency in Action Practical Multithreading》。记录一下学习过程，这是第三章关于线程互斥量的部分。
共享内存+互斥量实现linux进程间通信 分类： Linux ...
weixin_30405421的博客
03-26 420
一、共享内存简介 共享内存是进程间通信中高效方便的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针，两个进程可以对一块共享内存进行读写。 共享内存并未提供进程同步机制，使用共享内存完成进程间通信时，需要借助互斥量或者信号量来完成进程的同步。这里说一下互斥量与信号量的区别。互斥量用于线程的互斥，...
91-互斥量的鲁棒属性
进击的小学生
03-16 3352
上一文有一个遗留练习，很重要，不知道同学们有没有做。先说结论吧，如果其中一个进程在未释放互斥量的情况下挂掉了，将会导致另一个线程永远无法获得锁，然后就死锁了。为了能够让进程在异常终止时，释放掉互斥锁，需要指定 ROBUST 属性。所谓的 ROBUST，指是的健壮的意思。1. 相关函数可以通过下面两个函数设置和获取互斥量的鲁棒属性：int pthread_mutexattr_getrobust(con
linux多线程-----同步对象(互斥量、读写锁、条件变量)的属性
Be The Best！
04-01 2024
线程具有属性，同样用于线程同步的对象也有属性，主要有互斥量、读写锁和条件变量的属性。
linux 共享内存 互斥量
wqs880527的博客
11-04 229
linux 共享内存 互斥量
互相独立进程间共享内存互斥访问的解决办法
热门推荐
每天进步一点点，月薪三千不是梦
04-26 1万+
前提：两个进程互相独立，访问同一片共享内存存在问题：1、如何避免两个进程同时访问共享内存（一旦两个进程同时访问一个临界区，后果是程序崩溃）2、如果使用互斥锁，如何让两个进程拿到同一个互斥锁解决办法：针对问题1，可以使用信号，信号量，互斥锁来进行同步，但是信号和信号量需要两个进程都实现一套自己的逻辑（访问临界区前，先检查冲突标志，如果没有冲突则访问，并向其它的所有进程依次发送信号，告诉它们我要开始访...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值