【Linux】System V - 基于建造者模式的信號量

信號量和P、V原語

信號量集結構體

信號量操作接口

semget

semctl

semop

封裝Sem

關于建造者模式

信號量和P、V原語

信號量和 P、V 原語由 Dijkstra （迪杰斯特拉）提出

信號量值含義

S>0: S 表?可?資源的個數
S=0: 表??可?資源，?等待進程
S<0: |S| 表?等待隊列中進程個數

信號量結構體偽代碼

//信號量本質上是?個計數器
struct semaphore
{
? ? int value;
? ? pointer_PCB queue;
}

P原語

P(s)
{
? ? s.value = s.value--;
? ? if (s.value < 0)
? ? {
? ? ? ? // 該進程狀態置為等待狀狀態
? ? ? ? // 將該進程的PCB插??相應的等待隊列s.queue末尾
? ? }
}

V原語

V(s)
{
? ? s.value = s.value++;
? ? if (s.value > 0)
? ? {
? ? ? ? // 喚醒相應等待隊列s.queue中等待的??個進程
? ? ? ? // 改變其狀態為就緒態
? ? ? ? // 并將其插?OS就緒隊列
? ? }
}

信號量集結構體

The semid_ds data structure is defined in <sys / sem.h> as follows :
struct semid_ds {
? ? struct ipc_perm sem_perm; /* Ownership and permissions */
? ? time_t sem_otime; /* Last semop time */
? ? time_t sem_ctime; /* Last change time */
? ? unsigned long sem_nsems; /* No. of semaphores in set */
};
The ipc_perm structure is defined as follows(the highlighted fields
? ? are settable using IPC_SET) :
? ? struct ipc_perm {
? ? key_t __key; /* Key supplied to semget(2) */
? ? uid_t uid; /* Effective UID of owner */
? ? gid_t gid; /* Effective GID of owner */
? ? uid_t cuid; /* Effective UID of creator */
? ? gid_t cgid; /* Effective GID of creator */
? ? unsigned short mode; /* Permissions */
? ? unsigned short __seq; /* Sequence number */
};

信號量操作接口

semget

NAME
semget - get a System V semaphore set identifier

SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
RETURN VALUE
If successful, the return value will be the semaphore set identifier
(a nonnegative integer), otherwise, -1 is returned, with errno indicating the
error.

參數介紹

key: 信號量集的鍵值，同消息隊列和共享內存
nsems: 信號量集中信號量的個數
semflg: 同消息隊列和共享內存

semctl

NAME
semctl - System V semaphore control operations
SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);
This function has three or four arguments, depending on cmd.When there are four, the fourth has the type union semun.The calling program must define?this union as follows :
? ? union semun {
? ? int val; /* Value for SETVAL */
? ? struct semid_ds* buf; /* Buffer for IPC_STAT, IPC_SET */
? ? unsigned short* array; /* Array for GETALL, SETALL */
? ? struct seminfo* __buf; /* Buffer for IPC_INFO
? ? (Linux-specific) */
};
RETURN VALUE
On failure, semctl() returns - 1 with errno indicating the error.
Otherwise, the system call returns a nonnegative value depending on
cmd as follows :
GETNCNT the value of semncnt.
GETPID the value of sempid.
GETVAL the value of semval.
GETZCNT the value of semzcnt.
IPC_INFO the index of the highest used entry in the kernel's internal
array recording information about all semaphore sets. (This information can
? ? be used with repeated SEM_STAT or
? ? SEM_STAT_ANY operations to obtain information about all semaphore sets
? ? on the system.)
? ? SEM_INFO as for IPC_INFO.
? ? SEM_STAT the identifier of the semaphore set whose index was given in
? ? semid.
? ? SEM_STAT_ANY as for SEM_STAT.
? ? All other cmd values return 0 on success.

參數介紹

semid: 由 semget 返回的信號集標識碼
semnum: 信號集中信號量的序號

semnum: semctl() performs the control operation specified by cmd on the
System V semaphore set identified by semid, or on the semnum - th semaphore of
that set. (The semaphores in a set are numbered starting at 0.)

cmd: 將要采取的動作, 具體動作看 man ?冊

semop

NAME
semop, semtimedop - System V semaphore operations
SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf* sops, size_t nsops);
semop() performs operations on selected semaphores in the set indicated by
semid.Each of the nsops elements in the array pointed to by sops is a
structure that specifies an operation to be performed on a single semaphore.
The elements of this structure are of type struct sembuf, containing the
following members :
unsigned short sem_num; /* semaphore number */
short sem_op; /* semaphore operation ：-1，P操作。1，V操作
*/
short sem_flg; /* operation flags */
Flags recognized in sem_flg are IPC_NOWAIT and SEM_UNDO.If an operation specifies SEM_UNDO, it will be automatically undone when the process terminates.
RETURN VALUE
If successful, semop() and semtimedop() return 0; otherwise they
return -1 with errno indicating the error.

參數介紹

semid: 是該信號量的標識碼，也就是 semget 函數的返回值
sops: 指向?個結構 sembuf 的指針
nsops: sops 對應的信號量的個數，也就是可以同時對多個信號量進?PV操作

封裝Sem

我們使?信號量，簡化信號量使?，測試使??元信號量進?顯?器交替打印

Sem.hpp

#pragma once#include <iostream>
#include <string>
#include <memory>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>const std::string pathname = "/tmp";
int proj_id = 0x77;#define GET_SEM IPC_CREAT // 不給權限
#define BUILD_SEM (IPC_CREAT | IPC_EXCL | 0666)// 只關注使用和刪除
class Semaphore
{
public:Semaphore(int semid, int flag) : _semid(semid), _flag(flag){}void P(){struct sembuf sb; // 該結構系統提供sb.sem_num = 0;sb.sem_op = -1;sb.sem_flg = SEM_UNDO;int n = ::semop(_semid, &sb, 1);(void)n;}void V(){struct sembuf sb;sb.sem_num = 0;sb.sem_op = 1;sb.sem_flg = SEM_UNDO;int n = ::semop(_semid, &sb, 1);(void)n;}~Semaphore(){if(_flag == GET_SEM) return;// 讓信號量自動銷毀// 如果銷毀信號量集合：The argument semnum is ignoredint n = ::semctl(_semid, 0, IPC_RMID);(void)n;std::cout << "sem set destroy!" << std::endl;}private:int _semid;int _flag;
};using sem_sptr = std::shared_ptr<Semaphore>;// 使用一下簡單的建造者模式,用它來構建單sem
class SemaphoreBuilder
{
public:SemaphoreBuilder() : _val(-1){}SemaphoreBuilder &SetVal(int val){_val = val;return *this; // 支持連續訪問}sem_sptr Build(int flag){// 0. 先做一下簡單的合法性判斷if (_val < 0){std::cerr << "you must init first!" << std::endl;return nullptr;}// 1. 申請key值key_t k = ::ftok(pathname.c_str(), proj_id);if (k < 0)exit(1);// 2. 根據初始值，創建信號量集合int semid = ::semget(k, 1, flag); // 這里讓信號量集合中，只創建一個信號量就夠用了if (semid < 0)exit(2);if (BUILD_SEM == flag){// 3. 初始化信號量union semun // 該聯合體系統不提供，需要我們自己定義{int val;               /* Value for SETVAL */struct semid_ds *buf;  /* Buffer for IPC_STAT, IPC_SET */unsigned short *array; /* Array for GETALL, SETALL */struct seminfo *__buf; /* Buffer for IPC_INFO(Linux-specific) */} un;un.val = _val; // 設置為初始值int n = ::semctl(semid, 0, SETVAL, un);if (n < 0)exit(3);}// 4. 創建并返回信號量集合return std::make_shared<Semaphore>(semid, flag);}~SemaphoreBuilder(){}private:int _val; // 所有信號量的初始值
};

Writer.cc：測試信號量接口

#include "Sem.hpp"
#include <cstdio>
#include <time.h>
#include <unistd.h>int main()
{SemaphoreBuilder sb;auto fsem = sb.SetVal(1).Build(BUILD_SEM); // 創建信號量集合,只有一個信號量，初始化成為1,就是當做鎖來進行使用if (fork() == 0){auto csem = sb.Build(GET_SEM);int cnt = 10;while (cnt--){csem->P();printf("C");fflush(stdout);usleep(rand() % 95270);printf("C ");usleep(rand() % 43990);fflush(stdout);csem->V();}exit(0);}int cnt = 50;while (cnt--){fsem->P();printf("F");fflush(stdout);usleep(rand() % 95270);printf("F ");usleep(rand() % 43990);fflush(stdout);fsem->V();}return 0;
}

結論：

System V 信號量?命周期也是隨內核的
ipcs -s && ipcrm -s semid

關于建造者模式

Sem_V.hpp

#ifndef SEM_HPP
#define SEM_HPP#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>const std::string SEM_PATH = "/tmp";
const int SEM_PROJ_ID = 0x77;
const int defaultnum = 1;
#define GET_SEM (IPC_CREAT)
#define BUILD_SEM (IPC_CREAT | IPC_EXCL)///////////////////////////先設計建造者模式的代碼結構////////////// 一個把整數轉十六進制的函數
std::string intToHex(int num)
{char hex[64];snprintf(hex, sizeof(hex), "0x%x", num);return std::string(hex);
}// 產品類, 只需要關心自己的使用即可(刪除)
// 這里的Semaphore不是一個信號量！！而是一個信號量集合！！，要指明你要PV操作哪一個信號量！！
class Semaphore
{
private:void PV(int who, int data){struct sembuf sem_buf;sem_buf.sem_num = who;        // 信號量編號,從0開始sem_buf.sem_op = data;      // S + sem_buf.sem_opsem_buf.sem_flg = SEM_UNDO; // 不關心int n = semop(_semid, &sem_buf, 1);if (n < 0){std::cerr << "semop PV failed" << std::endl;}}
public:Semaphore(int semid) : _semid(semid){}int Id() const{return _semid;}void P(int who){PV(who, -1);}void V(int who){PV(who, 1);}~Semaphore(){if (_semid >= 0){int n = semctl(_semid, 0, IPC_RMID);if (n < 0){std::cerr << "semctl IPC_RMID failed" << std::endl;}std::cout << "Semaphore " << _semid << " removed" << std::endl;}}private:int _semid;// key_t _key; // 信號量集合的鍵值// int _perm;  // 權限// int _num;   // 信號量集合的個數
};// 建造者接口
class SemaphoreBuilder
{
public:virtual ~SemaphoreBuilder() = default;virtual void BuildKey() = 0;virtual void SetPermission(int perm) = 0;virtual void SetSemNum(int num) = 0;virtual void SetInitVal(std::vector<int> initVal) = 0;virtual void Build(int flag) = 0;virtual void InitSem() = 0;virtual std::shared_ptr<Semaphore> GetSem() = 0;
};// 具體建造者類
class ConcreteSemaphoreBuilder : public SemaphoreBuilder
{
public:ConcreteSemaphoreBuilder() {}virtual void BuildKey() override{// 1. 構建鍵值std::cout << "Building a semaphore" << std::endl;_key = ftok(SEM_PATH.c_str(), SEM_PROJ_ID);if (_key < 0){std::cerr << "ftok failed" << std::endl;exit(1);}std::cout << "Got key: " << intToHex(_key) << std::endl;}virtual void SetPermission(int perm) override{_perm = perm;}virtual void SetSemNum(int num) override{_num = num;}virtual void SetInitVal(std::vector<int> initVal) override{_initVal = initVal;}virtual void Build(int flag) override{// 2. 創建信號量集合int semid = semget(_key, _num, flag | _perm);if (semid < 0){std::cerr << "semget failed" << std::endl;exit(2);}std::cout << "Got semaphore id: " << semid << std::endl;_sem = std::make_shared<Semaphore>(semid);}virtual void InitSem() override{if (_num > 0 && _initVal.size() == _num){// 3. 初始化信號量集合for (int i = 0; i < _num; i++){if (!Init(_sem->Id(), i, _initVal[i])){std::cerr << "Init failed" << std::endl;exit(3);}}}}virtual std::shared_ptr<Semaphore> GetSem() override{ return _sem; }
private:bool Init(int semid, int num, int val){union semun{int val;               /* Value for SETVAL */struct semid_ds *buf;  /* Buffer for IPC_STAT, IPC_SET */unsigned short *array; /* Array for GETALL, SETALL */struct seminfo *__buf; /* Buffer for IPC_INFO(Linux-specific) */} un;un.val = val;int n = semctl(semid, num, SETVAL, un);if (n < 0){std::cerr << "semctl SETVAL failed" << std::endl;return false;}return true;}private:key_t _key;                      // 信號量集合的鍵值int _perm;                       // 權限int _num;                        // 信號量集合的個數std::vector<int> _initVal;       // 初始值std::shared_ptr<Semaphore> _sem; // 我們要創建的具體產品
};// 指揮者類
class Director
{
public:void Construct(std::shared_ptr<SemaphoreBuilder> builder, int flag, int perm = 0666, int num = defaultnum, std::vector<int> initVal = {1}){builder->BuildKey();builder->SetPermission(perm);builder->SetSemNum(num);builder->SetInitVal(initVal);builder->Build(flag);if (flag == BUILD_SEM){builder->InitSem();}}
};#endif // SEM_HPP

Writer.cc

#include "Sem_V.hpp"
#include <unistd.h>
#include <ctime>
#include <cstdio>int main()
{// 基于抽象接口類的具體建造者std::shared_ptr<SemaphoreBuilder> builder = std::make_shared<ConcreteSemaphoreBuilder>();// 指揮者對象std::shared_ptr<Director> director = std::make_shared<Director>();// 在指揮者的指導下，完成建造過程director->Construct(builder, BUILD_SEM, 0600, 3, {1, 2, 3});// 完成了對象的創建的過程，獲取對象auto fsem = builder->GetSem();// sleep(10);// SemaphoreBuilder sb;// auto fsem = sb.SetVar(1).build(BUILD_SEM, 1);srand(time(0) ^ getpid());pid_t pid = fork();// 我們期望的是，父子進行打印的時候，C或者F必須成對出現！保證打印是原子的.if (pid == 0){director->Construct(builder, GET_SEM);auto csem = builder->GetSem();while (true){// csem->P(0);printf("C");usleep(rand() % 95270);fflush(stdout);printf("C");usleep(rand() % 43990);fflush(stdout);// csem->V(0);}}while (true){// fsem->P(0);printf("F");usleep(rand() % 95270);fflush(stdout);printf("F");usleep(rand() % 43990);fflush(stdout);// fsem->V(0);}return 0;
}