Linux C/C++ 历程控制

1.信号

​ 信号(signal)是软件中断，是历程之间相互传递消息的一种方法，用于关照历程发生了变乱，但
是，不能给历程传递任何数据。
​ 信号产生的缘故原由有很多，在 Shell 中，可以用 kill 和 killall 命令发送信号:

1. ki -信号的类型 进程编号
2. killall -信号的类型 进程名

复制代码

如果命令无效，需安装psmisc

1. sudo yum install psmisc

复制代码

信号的处置惩罚：

• 对该信号的处置惩罚采取系统的默认操作，大部门的信号的默认操作是终止历程
  
• 设置信号的处置惩罚函数，收到信号后，由该函数来处置惩罚
  
• 忽略某个信号，对该信号不做任何处置惩罚，就像未发生过一样
  

signal()函数可以设置步调对信号的处置惩罚方式

1. 函数声明：
2.         sighandler_t signal(int signum,sighandler_t handler);
3.        
4. signum        //信号编号
5. handler        //信号的处理方式，有三种
6. 1）SIG_DFL:恢复参数signum所指信号处理方法
7. 2)一个自定义处理信号的函数，函数的形参是信号的编号
8. 3)SIG_IGN:忽略参数signum所指信号

复制代码

1. #include<iostream>
2. #include<signal.h>
3. #include<unistd.h>
4. using namespace std;
6. void func(int signum)
7. {
8.     cout<<"signals"<<endl;
9. }
10. int main()
11. {
13.     signal(1,func);//注册回调函数func()
14.     signal(15,func);
15.     signal(2,SIG_IGN);//忽略2信号
16.     signal(15,SIG_DFL);//恢复15信号
17.    
18.     alarm(5);                //5s定时发送14信号
19.    
20.     while(true)
21.     {
22.         cout<<1<<endl;
23.         sleep(1);
24.     }
25. }

复制代码

应用场合：
​ 服务步调运行在后台，如果想让中止它，杀掉不是个好办法，因为历程被杀的时间，是突然殒命没有安排善后工作。
​ 如果向服务步调发送一个信号，服务步调收到这个信号后，调用一个函数，在函数中编写善后的代码，步调就可以有筹划的退出。
​ 向服务步调发送0的信号，可以检测步调是否存活。

1. [root@localhost 06demoerror]# killall -0 demo_error
2. demo_error: no process found

复制代码

1. #include<iostream>
2. #include<signal.h>
3. #include<unistd.h>
4. using namespace std;
6. void EXIT(int signum)
7. {
8.         cout<<"程序退出\n"<<endl;
9.         exit(0)；
10. }
12. int main(int argc,cgar *argv[])
13. {
14.         //忽略所有信号，防止进程被信号异常终止
15.         for(int ii = 1;ii <= 64;ii++) signal(ii,SIG_IGN);
16.        
17.         //收到2和15信号（Ctrl+C和kill、killall）,程序退出
18.         signal(2,EXIT);
19.         signal(15,EXIT);
20.        
21.         while(true)
22.         {
23.                 cout<<"执行一次任务"<<endl;
24.                 sleep(1);
25.         }
26. }

复制代码

2.历程终止

有八种方式可以终止历程，此中5中为正常终止
1）在main()函数中用return返回
2）在恣意函数中调用exit()
3）在恣意函数中调用_exit()或 _Exit()函数
4）在最后一个线程从其他启动例程（线程主函数）用return返回
5）在最后一个线程中调用pthread_exit()返回
非常终止有三种方式
6）调用abort()函数终止
7）吸取到一个信号
8）最后一给线程对取消请求作出响应
在main()函数中，return返回值即终止状态，如果没有return或调用exit(),历程终止状态为0
在Shell中检察简称终止状态

1. [root@localhost 06demoerror]# ./demo
2. [root@localhost 06demoerror]# echo $?
3. 0

复制代码

正常终止历程的三个函数

1. void exit(int status);
2. void _exit(int status);
3. void _Exit(int status);                //status为进程终止状态

复制代码

  如果历程被非常终止，终止状态为 非0
    用于服务步调的调度、日志和监控
  资源释放的标题：

• return 体现函数返回,会调用局部对象的析构函数，main()函数中的 return 还会调用全局对象的析构函数。
  
• exit()体现终止历程，不会调用局部对象的析构函数，只调用全局对象的析构函数。
  
• exit()会实验清理工作，然后退出，exit()和 Exit()直接退出，不会实验清理工作。
  

历程的终止函数：atexit()登记终止函数（最多32个），这些函数exit()自动调用

1. int atexit(void (*function)(void));

复制代码

  exit()调用终止函数的次序与登记时相反
  3.调用可实验步调

Linux提供了system()函数和exec函数族，在C++步调中，可以实验其他步调（二进制文件、操作系统命令或者Shell脚本）
system()函数

1. #include<stdlib.h>
3. int system(const char * string);
5. 执行程序不存在，返回非0
6. 执行成功，程序终止状态是0，system()函数返回0
7. 执行成功，程序终止状态不是0，system()函数返回非0

复制代码

exec()函数族
exec函数族提供了另一种在历程中调用步调（二进制文件或Shell脚本）的方法

1. int execl(const char *path,const char *arg,…)；
2. int execlp(const char *file,const char *arg,…)；
3. int execle(const char *path,const char *arg,…,char *const envp[])；
4. int execv(const char *path,char *const argv[])；
5. int execvp(const char *file,char *const argv[])；
6. int execvpe(const char *file,char *const argv[],char *const envp[])；

复制代码

  注意：
  1）如果实验失败则直接返回-1，失败缘故原由存于errno中
  2）新历程的历程编号和原历程雷同，但是新历程代替了原历程的代码段、数据段和堆栈
  3）如果实验乐成则函数不会返回，当在主步调乐成调用了exec后，被调用的步调将代替调用者步调，也就是说exec函数之后的代码都不会被实验
  4）在实际开发中，最常用execl()和execv()
  

---

4.历程创建

整个Linux系统全部的历程是一个树形结构

• 0号历程是所有历程的祖先，他创建了1号和2号历程
  
• 1号历程（systemed）负责实验内核的初始化工作和举行系统设置
  
• 2号历程（kthreadd）负责所有内核线程的调度和管理
  
  1. yum -y install psmisc
  2. pstree -p 进程编号        //查看进程树

  复制代码

每个历程都有一个非负整数体现的唯一历程ID。固然是唯一的，但是历程ID可以复用。当一个历程终止后，其历程ID就成了复用的候选者。Linux采取耽误服用算法，让新建历程的ID不同于迩来终止的历程所使用的ID。这样防止了新历程被误认为是使用了同一ID的某个已终止历程。

1. pid_t getpid(void)        //获取当前进程ID
2. pid_t getppid(void)        //获取父进程ID

复制代码

fork()函数
一个现有的历程可以调用fork()函数创建一个新历程

1. pid_t fork(void);

复制代码

fork()函数被调用一次，但返回两次。两次返回的区别是子历程返回值是0，而父历程返回值是子历程的历程ID。
子历程和父历程继承实验fork()之后的代码，子历程是父历程的副本。
子历程得到了父历程数据空间、堆和栈的副本。
   子历程拥有的是副本，不是共享
  fork()之后，父历程和子历程的实验次序是不确定的。
fork()两种用法：

• 父历程复制自己，然后，父历程和子历程分别实验不同的代码。这种用法在网络服务步调中很常见，父历程期待客户端的毗连请求，当请求到达时，父历程调用fork()，让子历程处置惩罚些请求，而父历程则继承期待下一个毗连请求。
  
• 历程要实验另一个步调。这种用法在 Shell 中很常见，子历程从 fork()返回后立即调用 exec。
  

共享文件：fork()的一个特性是在父历程中打开的文件形貌符都会被复制到子历程中，父历程和子历程共享同一个文件偏移量。
   如果父历程和子历程写同一文件形貌符指向的文件，但又没有任何同步形式，那么他们的输出可能会相互混合。
  vfork()函数
vfork()函数的调用和返回值与 fork()雷同，但两者的语义不同。
vfork()函数用于创建一个新历程，而该新历程的目标是 exec 一个新步调，它不复制父历程的所在空间，因为子历程会立即调用 exec，于是也就不会使用父历程的所在空间。如果子历程使用了父历程的所在空间，可能会带来未知的结果。
vfork()和fork()的另一个区别是：vfork()包管子历程先运行，在子历程调用exec或exit()之后，父历程才规复运行

---

5.僵尸历程

如果父历程比子历程先退出，子历程将被1号历程托管(这也是一种让步调在后台运行的方法)。
如果子历程比父历程先退出，而父历程没有处置惩罚子历程退出的信息，那么，子历程将成为僵尸进
程。
僵尸历程有什么危害?
内核为每个子历程保留了一个数据结构，包罗历程编号、终止状态、使用CPU 时间等。父历程如果处置惩罚了子历程退出的信息，内核就会释放这个数据结构，父历程如果没有处置惩罚子历程退出的信息，内核就不会释放这个数据结构，子历程的历程编号将一直被占用。系统可用的历程编号是有限的，如果产生了大量的僵尸历程，将因为没有可用的历程编号而导致系统不能产生新的历程。
僵尸历程的制止:
1)子历程退出的时间，内核会向父历程发头 SIGCHLD 信号，如果父历程用 signal(SIGCHLD,SIGGN)关照内核，体现自己对子历程的退出不感兴趣，那么子历程退出后会立即释放数据结构。
2)父历程通过 wait()/waitpid()等函数期待子历程结束，在子历程退出之前，父历程将阻塞期待。

1. pid_t wait(int *stat_loc);
2. pid_t waitpid(pid_t pid, int *stat_loc, int options);
3. pid_t wait3(int *status, int options, struct rusage *rusage);
4. pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);

复制代码

返回值是子历程的编号
stat_loc 是子历程终止的信息:
a)如果是正常终止，宏 WIFEXITED(stat loc)返回真，宏 WEXITSTATUS(stat_loc)可获取终止状态;
b)如果是非常终止，宏 WTERMSIG(stat loc)可获取终止历程的信号
3)如果父历程很忙，可以捕捉 SIGCHLD 信号，在信号处置惩罚函数中调用 wait()/waitpid()。

---

6.多历程与信号

Linux 操作系统提供了 kill和 killall 命令向历程发送信号，在步调中，可以用kill()函数向别的历程发送信号。
函数声明:

1. int kill(pid t pid, int sig);

复制代码

kil()函数将参数 sig 指定的信号给参数 pid 指定的历程。
参数 pid 有几种情况:
1)pid>0 将信号传给历程号为 pid 的历程。
2)pid=0 将信号传给和如今历程雷同历程组的所有历程，常用于历程给子历程发送信号，注意，发送信号者历程也会收到自己发出的信号。
3)pid=-1 将信号广播传送给系统内所有的历程，比方系统关机时，会向所有的登录窗口广播关机信息。
sig:准备发送的信号代码，如果其值为0则没有任何信号送出，但是系统会实验错误查抄，通常会利用 sig 值为零来检验某个历程是否仍在运行。
返回值说明: 乐成实验时，返回0;失败返回-1，errno 被设置。
8.共享内存

多线程共享历程的所在空间，如果多个线程必要访问同一块内存，用全局变量就可以了。
在多历程中，每个历程的所在空间是独立的，不共享的，如果多个历程必要访问同一块内存，不能用全局变量，只能用共享内存。“
共享内存(Shared Memory)答应多个历程(不要求历程之间有血缘关系)访问同一个内存空间是多个历程之间共享和传递数据最高效的方式。历程可以将共享内存毗连到它们自己的所在空间中，如果某个历程修改了共享内存中的数据，别的的历程读到的数据也将会改变。
共享内存并未提供锁机制，也就是说，在某一个历程对共享内存的举行读/写的时间，不会制止别的历程对它的读/写。如果要对共享内存的读/写加锁，可以使用信号量。
Linux 中提供了一组函数用于操作共享内存。
shmget函数
该函数用于创建/获取共享内存。

1. int shmget(key_t key, size_t size, int shmflg);

复制代码

key 共享内存的键值，是一个整数（typedef unsigned int key_t），一样平常采取十六进制，比方0x5005，不同共享内存的 key 不能雷同。
size 待创建的共享内存的巨细，以字节为单位。
shmfg 共享内存的访问权限，与文件的权限一样，比方 0666|IPC_CREAT，体现全部用户对它可读写，IPC_CREAT体现如果共享内存不存在，就创建它。
返回值:乐成返回共享内存的id(一个大于0的整数)，失败返回-1

1. ipcs -m        //查看系统的共享内存
2. ipcrm -m 共享内存id        //手工删除共享内存

复制代码

shmat 函数
该函数用于把共享内存毗连到当前历程的所在空间。

1. void *shmat(int shmid, const void *shmaddr, int shmflg);

复制代码

shmid 由 shmget()函数返回的共享内存标识。
shmaddr 指定共享内存毗连到当前历程中的所在位置，通常填0，体现让系统来选择共享内存的
所在。
shmflg 标记位，通常填 0。
调用乐成时返回共享内存起始所在，失败返回(void*)-1
shmdt 函数
该函数用于将共享内存从当前历程中分离，相称于shmat()函数的反操作。

1. int shmdt(const void *shmaddr);

复制代码

shmaddr shmat()函数返回的所在。
调用乐成时返回 0，失败时返回-1。
shmctl 函数
该函数用于操作共享内存，最常用的操作是删除共享内存。
int shmctl(int shmid, int command, struct shmid ds *buf);
shmid shmget()函数返回的共享内存 id。
command操作共享内存的指令，如果要删除共享内存，填IPC RMID。
buf 操作共享内存的数据结构的所在，如果要删除共享内存，填 0。
调用乐成时返回0，失败时返回-1。
   注意，用root 创建的共享内存，不管创建的权限是什么，普通用户无法删除。
  

---

9.循环队列

• 共享内存不能自动扩展，只能采取C++内置的数据类型
  
• 共享内存不能采取STL容器，也不能使用移动语义
  
• 如果要实现多历程的生产/消费者模型，只能采取循环队列
  

1. //_public.h
2. #ifndef __PUBLIC_HH
3. #define __PUBLIC_HH 1
5. #include <iostream>
6. #include <cstdio>
7. #include <cstdlib>
8. #include <cstring>
9. #include <unistd.h>
10. #include <sys/ipc.h>
11. #include <sys/shm.h>
12. #include <sys/types.h>
13. #include <sys/sem.h>
14. using namespace std;
16. // 循环队列。
17. template <class TT, int MaxLength>
18. class squeue
19. {
20. private:
21.   bool m_inited;              // 队列被初始化标志，true-已初始化；false-未初始化。
22.   TT   m_data[MaxLength];     // 用数组存储循环队列中的元素。
23.   int  m_head;                // 队列的头指针。
24.   int  m_tail;                // 队列的尾指针，指向队尾元素。
25.   int  m_length;              // 队列的实际长度。   
26.   squeue(const squeue &) = delete;             // 禁用拷贝构造函数。
27.   squeue &operator=(const squeue &) = delete;  // 禁用赋值函数。
28. public:
30.   squeue() { init(); }  // 构造函数。
32.   // 循环队列的初始化操作。
33.   // 注意：如果用于共享内存的队列，不会调用构造函数，必须调用此函数初始化。
34.   void init()  
35.   {
36.     if (m_inited!=true)      // 循环队列的初始化只能执行一次。
37.     {
38.       m_head=0;              // 头指针。
39.       m_tail=MaxLength-1;    // 为了方便写代码，初始化时，尾指针指向队列的最后一个位置。
40.       m_length=0;            // 队列的实际长度。
41.       memset(m_data,0,sizeof(m_data));  // 数组元素清零。
42.       m_inited=true;
43.     }
44.   }
46.   // 元素入队，返回值：false-失败；true-成功。
47.   bool push(const TT &ee)
48.   {
49.     if (full() == true)
50.     {
51.       cout << "循环队列已满，入队失败。\n"; return false;
52.     }
54.     // 先移动队尾指针，然后再拷贝数据。
55.     m_tail=(m_tail+1)%MaxLength;  // 队尾指针后移。
56.     m_data[m_tail]=ee;
57.     m_length++;   
59.     return true;
60.   }
62.   // 求循环队列的长度，返回值：>=0-队列中元素的个数。
63.   int  size()                  
64.   {
65.     return m_length;   
66.   }
68.   // 判断循环队列是否为空，返回值：true-空，false-非空。
69.   bool empty()                    
70.   {
71.     if (m_length == 0) return true;   
73.     return false;
74.   }
76.   // 判断循环队列是否已满，返回值：true-已满，false-未满。
77.   bool full()
78.   {
79.     if (m_length == MaxLength) return true;   
81.     return false;
82.   }
84.   // 查看队头元素的值，元素不出队。
85.   TT& front()
86.   {
87.     return m_data[m_head];
88.   }
90.   // 元素出队，返回值：false-失败；true-成功。
91.   bool pop()
92.   {
93.     if (empty() == true) return false;
95.     m_head=(m_head+1)%MaxLength;  // 队列头指针后移。
96.     m_length--;   
98.     return true;
99.   }
101.   // 显示循环队列中全部的元素。
102.   // 这是一个临时的用于调试的函数，队列中元素的数据类型支持cout输出才可用。
103.   void printqueue()                    
104.   {
105.     for (int ii = 0; ii < size(); ii++)
106.     {
107.       cout << "m_data[" << (m_head+ii)%MaxLength << "],value=" \
108.            << m_data[(m_head+ii)%MaxLength] << endl;
109.     }
110.   }
111. };
113. // 信号量。
114. class csemp
115. {
116. private:
117.   union semun  // 用于信号量操作的共同体。
118.   {
119.     int val;
120.     struct semid_ds *buf;
121.     unsigned short  *arry;
122.   };
124.   int   m_semid;         // 信号量id（描述符）。
126.   // 如果把sem_flg设置为SEM_UNDO，操作系统将跟踪进程对信号量的修改情况，
127.   // 在全部修改过信号量的进程（正常或异常）终止后，操作系统将把信号量恢复为初始值。
128.   // 如果信号量用于互斥锁，设置为SEM_UNDO。
129.   // 如果信号量用于生产消费者模型，设置为0。
130.   short m_sem_flg;
132.   csemp(const csemp &) = delete;             // 禁用拷贝构造函数。
133.   csemp &operator=(const csemp &) = delete;  // 禁用赋值函数。
134. public:
135.   csemp():m_semid(-1){}
136.   // 如果信号量已存在，获取信号量；如果信号量不存在，则创建它并初始化为value。
137.   // 如果用于互斥锁，value填1，sem_flg填SEM_UNDO。
138.   // 如果用于生产消费者模型，value填0，sem_flg填0。
139.   bool init(key_t key,unsigned short value=1,short sem_flg=SEM_UNDO);
140.   bool wait(short value=-1);// 信号量的P操作，如果信号量的值是0，将阻塞等待，直到信号量的值大于0。
141.   bool post(short value=1); // 信号量的V操作。
142.   int  getvalue();           // 获取信号量的值，成功返回信号量的值，失败返回-1。
143.   bool destroy();            // 销毁信号量。
144. ~csemp();
145. };
147. #endif

复制代码

1. //_public.cpp
2. #include "_public.h"
4. // 如果信号量已存在，获取信号量；如果信号量不存在，则创建它并初始化为value。
5. // 如果用于互斥锁，value填1，sem_flg填SEM_UNDO。
6. // 如果用于生产消费者模型，value填0，sem_flg填0。
7. bool csemp::init(key_t key,unsigned short value,short sem_flg)
8. {
9.   if (m_semid!=-1) return false; // 如果已经初始化了，不必再次初始化。
11.   m_sem_flg=sem_flg;
13.   // 信号量的初始化不能直接用semget(key,1,0666|IPC_CREAT)
14.   // 因为信号量创建后，初始值是0，如果用于互斥锁，需要把它的初始值设置为1，
15.   // 而获取信号量则不需要设置初始值，所以，创建信号量和获取信号量的流程不同。
17.   // 信号量的初始化分三个步骤：
18.   // 1）获取信号量，如果成功，函数返回。
19.   // 2）如果失败，则创建信号量。
20.   // 3) 设置信号量的初始值。
22.   // 获取信号量。
23.   if ( (m_semid=semget(key,1,0666)) == -1)
24.   {
25.     // 如果信号量不存在，创建它。
26.     if (errno==ENOENT)
27.     {
28.       // 用IPC_EXCL标志确保只有一个进程创建并初始化信号量，其它进程只能获取。
29.       if ( (m_semid=semget(key,1,0666|IPC_CREAT|IPC_EXCL)) == -1)
30.       {
31.         if (errno==EEXIST) // 如果错误代码是信号量已存在，则再次获取信号量。
32.         {
33.           if ( (m_semid=semget(key,1,0666)) == -1)
34.           {
35.             perror("init 1 semget()"); return false;
36.           }
37.           return true;
38.         }
39.         else  // 如果是其它错误，返回失败。
40.         {
41.           perror("init 2 semget()"); return false;
42.         }
43.       }
45.       // 信号量创建成功后，还需要把它初始化成value。
46.       union semun sem_union;
47.       sem_union.val = value;   // 设置信号量的初始值。
48.       if (semctl(m_semid,0,SETVAL,sem_union) <  0)
49.       {
50.         perror("init semctl()"); return false;
51.       }
52.     }
53.     else
54.     { perror("init 3 semget()"); return false; }
55.   }
57.   return true;
58. }
60. // 信号量的P操作（把信号量的值减value），如果信号量的值是0，将阻塞等待，直到信号量的值大于0。
61. bool csemp::wait(short value)
62. {
63.   if (m_semid==-1) return false;
65.   struct sembuf sem_b;
66.   sem_b.sem_num = 0;      // 信号量编号，0代表第一个信号量。
67.   sem_b.sem_op = value;   // P操作的value必须小于0。
68.   sem_b.sem_flg = m_sem_flg;
69.   if (semop(m_semid,&sem_b,1) == -1) { perror("p semop()"); return false; }
71.   return true;
72. }
74. // 信号量的V操作（把信号量的值减value）。
75. bool csemp::post(short value)
76. {
77.   if (m_semid==-1) return false;
79.   struct sembuf sem_b;
80.   sem_b.sem_num = 0;     // 信号量编号，0代表第一个信号量。
81.   sem_b.sem_op = value;  // V操作的value必须大于0。
82.   sem_b.sem_flg = m_sem_flg;
83.   if (semop(m_semid,&sem_b,1) == -1) { perror("V semop()"); return false; }
85.   return true;
86. }
88. // 获取信号量的值，成功返回信号量的值，失败返回-1。
89. int csemp::getvalue()
90. {
91.   return semctl(m_semid,0,GETVAL);
92. }
94. // 销毁信号量。
95. bool csemp::destroy()
96. {
97.   if (m_semid==-1) return false;
99.   if (semctl(m_semid,0,IPC_RMID) == -1) { perror("destroy semctl()"); return false; }
101.   return true;
102. }
104. csemp::~csemp()
105. {
106. }

复制代码

测试步调1

1. // demo1.cpp，本程序演示循环队列的使用。
2. #include "_public.h"
4. int main()
5. {
6.   using ElemType=int;
8.   squeue<ElemType,5> QQ;
10.   ElemType ee;      // 创建一个数据元素。
12.   cout << "元素（1、2、3）入队。\n";
13.   ee=1;  QQ.push(ee);
14.   ee=2;  QQ.push(ee);
15.   ee=3;  QQ.push(ee);
17.   cout << "队列的长度是" << QQ.size() << endl;
18.   QQ.printqueue();
20.   ee=QQ.front(); QQ.pop(); cout << "出队的元素值为" << ee << endl;
21.   ee=QQ.front(); QQ.pop(); cout << "出队的元素值为" << ee << endl;
23.   cout << "队列的长度是" << QQ.size() << endl;
24.   QQ.printqueue();
26.   cout << "元素（11、12、13、14、15）入队。\n";
27.   ee=11;  QQ.push(ee);
28.   ee=12;  QQ.push(ee);
29.   ee=13;  QQ.push(ee);
30.   ee=14;  QQ.push(ee);
31.   ee=15;  QQ.push(ee);
33.   cout << "队列的长度是" << QQ.size() << endl;
34.   QQ.printqueue();
35. }

复制代码

输出

1. [root@localhost 07demosqueue]# g++ -o demo1 demo1.cpp _public.h _public.cpp
2. [root@localhost 07demosqueue]# ./demo1
3. 元素（1、2、3）入队。
4. 队列的长度是3
5. m_data[0],value=1
6. m_data[1],value=2
7. m_data[2],value=3
8. 出队的元素值为1
9. 出队的元素值为2
10. 队列的长度是1
11. m_data[2],value=3
12. 元素（11、12、13、14、15）入队。
13. 循环队列已满，入队失败。
14. 队列的长度是5
15. m_data[2],value=3
16. m_data[3],value=11
17. m_data[4],value=12
18. m_data[0],value=13
19. m_data[1],value=14

复制代码

测试步调2

1. // demo2.cpp，本程序演示基于共享内存的循环队列。
2. #include "_public.h"
4. int main()
5. {
6.   using ElemType=int;
8.   // 初始化共享内存。
9.   int shmid=shmget(0x5005, sizeof(squeue<ElemType,5>), 0640|IPC_CREAT);
10.   if ( shmid ==-1 )
11.   {
12.     cout << "shmget(0x5005) failed.\n"; return -1;
13.   }
15.   // 把共享内存连接到当前进程的地址空间。
16.   squeue<ElemType,5> *QQ=(squeue<ElemType,5> *)shmat(shmid,0,0);
17.   if ( QQ==(void *)-1 )
18.   {
19.     cout << "shmat() failed\n"; return -1;
20.   }
22.   QQ->init();       // 初始化循环队列。
24.   ElemType ee;      // 创建一个数据元素。
26.   cout << "元素（1、2、3）入队。\n";
27.   ee=1;  QQ->push(ee);
28.   ee=2;  QQ->push(ee);
29.   ee=3;  QQ->push(ee);
31.   cout << "队列的长度是" << QQ->size() << endl;
32.   QQ->printqueue();
34.   ee=QQ->front(); QQ->pop(); cout << "出队的元素值为" << ee << endl;
35.   ee=QQ->front(); QQ->pop(); cout << "出队的元素值为" << ee << endl;
37.   cout << "队列的长度是" << QQ->size() << endl;
38.   QQ->printqueue();
40.   cout << "元素（11、12、13、14、15）入队。\n";
41.   ee=11;  QQ->push(ee);
42.   ee=12;  QQ->push(ee);
43.   ee=13;  QQ->push(ee);
44.   ee=14;  QQ->push(ee);
45.   ee=15;  QQ->push(ee);
47.   cout << "队列的长度是" << QQ->size() << endl;
48.   QQ->printqueue();
50.   shmdt(QQ);  // 把共享内存从当前进程中分离。
51. }

复制代码

输出

1. [root@localhost 07demosqueue]# g++ -o demo2 demo2.cpp _public.h _public.cpp
2. [root@localhost 07demosqueue]# ./demo2
3. 元素（1、2、3）入队。
4. 队列的长度是3
5. m_data[0],value=1
6. m_data[1],value=2
7. m_data[2],value=3
8. 出队的元素值为1
9. 出队的元素值为2
10. 队列的长度是1
11. m_data[2],value=3
12. 元素（11、12、13、14、15）入队。
13. 循环队列已满，入队失败。
14. 队列的长度是5
15. m_data[2],value=3
16. m_data[3],value=11
17. m_data[4],value=12
18. m_data[0],value=13
19. m_data[1],value=14
20. [root@localhost 07demosqueue]# ./demo2
21. 元素（1、2、3）入队。
22. 循环队列已满，入队失败。
23. 循环队列已满，入队失败。
24. 循环队列已满，入队失败。
25. 队列的长度是5
26. m_data[2],value=3
27. m_data[3],value=11
28. m_data[4],value=12
29. m_data[0],value=13
30. m_data[1],value=14
31. 出队的元素值为3
32. 出队的元素值为11
33. 队列的长度是3
34. m_data[4],value=12
35. m_data[0],value=13
36. m_data[1],value=14
37. 元素（11、12、13、14、15）入队。
38. 循环队列已满，入队失败。
39. 循环队列已满，入队失败。
40. 循环队列已满，入队失败。
41. 队列的长度是5
42. m_data[4],value=12
43. m_data[0],value=13
44. m_data[1],value=14
45. m_data[2],value=11
46. m_data[3],value=12

复制代码

---

10. 信号量的根本概念

• 信号量本质上是一个非负数(>0)的计数器。
  
• 用于给共享资源创建一个标记，体现该共享资源被占用情况。
  
• P操作(wait)将信号量的值减1，如果信号量的值为0，将阻塞期待，直到信号量的值大于0。
  
• V操作(post) 将信号量的值加1，任何时间都不会阻塞。
  
• 如果约定信号量的取值只是0和1(0-资源不可用;1-资源可用)可以实现互斥锁。
  
• 如果约定信号量的取值体现可用资源的数量，可以实现生产/消费者模型。
  

1. // 信号量。
2. class csemp
3. {
4. private:
5.   union semun  // 用于信号量操作的共同体。
6.   {
7.     int val;
8.     struct semid_ds *buf;
9.     unsigned short  *arry;
10.   };
12.   int   m_semid;         // 信号量id（描述符）。
14.   // 如果把sem_flg设置为SEM_UNDO，操作系统将跟踪进程对信号量的修改情况，
15.   // 在全部修改过信号量的进程（正常或异常）终止后，操作系统将把信号量恢复为初始值。
16.   // 如果信号量用于互斥锁，设置为SEM_UNDO。
17.   // 如果信号量用于生产消费者模型，设置为0。
18.   short m_sem_flg;
20.   csemp(const csemp &) = delete;             // 禁用拷贝构造函数。
21.   csemp &operator=(const csemp &) = delete;  // 禁用赋值函数。
22. public:
23.   csemp():m_semid(-1){}
24.   // 如果信号量已存在，获取信号量；如果信号量不存在，则创建它并初始化为value。
25.   // 如果用于互斥锁，value填1，sem_flg填SEM_UNDO。
26.   // 如果用于生产消费者模型，value填0，sem_flg填0。
27.   bool init(key_t key,unsigned short value=1,short sem_flg=SEM_UNDO);
28.   bool wait(short value=-1);// 信号量的P操作，如果信号量的值是0，将阻塞等待，直到信号量的值大于0。
29.   bool post(short value=1); // 信号量的V操作。
30.   int  getvalue();           // 获取信号量的值，成功返回信号量的值，失败返回-1。
31.   bool destroy();            // 销毁信号量。
32. ~csemp();
33. };

复制代码

1. // 如果信号量已存在，获取信号量；如果信号量不存在，则创建它并初始化为value。
2. // 如果用于互斥锁，value填1，sem_flg填SEM_UNDO。
3. // 如果用于生产消费者模型，value填0，sem_flg填0。
4. bool csemp::init(key_t key,unsigned short value,short sem_flg)
5. {
6.   if (m_semid!=-1) return false; // 如果已经初始化了，不必再次初始化。
8.   m_sem_flg=sem_flg;
10.   // 信号量的初始化不能直接用semget(key,1,0666|IPC_CREAT)
11.   // 因为信号量创建后，初始值是0，如果用于互斥锁，需要把它的初始值设置为1，
12.   // 而获取信号量则不需要设置初始值，所以，创建信号量和获取信号量的流程不同。
14.   // 信号量的初始化分三个步骤：
15.   // 1）获取信号量，如果成功，函数返回。
16.   // 2）如果失败，则创建信号量。
17.   // 3) 设置信号量的初始值。
19.   // 获取信号量。
20.   if ( (m_semid=semget(key,1,0666)) == -1)
21.   {
22.     // 如果信号量不存在，创建它。
23.     if (errno==ENOENT)
24.     {
25.       // 用IPC_EXCL标志确保只有一个进程创建并初始化信号量，其它进程只能获取。
26.       if ( (m_semid=semget(key,1,0666|IPC_CREAT|IPC_EXCL)) == -1)
27.       {
28.         if (errno==EEXIST) // 如果错误代码是信号量已存在，则再次获取信号量。
29.         {
30.           if ( (m_semid=semget(key,1,0666)) == -1)
31.           {
32.             perror("init 1 semget()"); return false;
33.           }
34.           return true;
35.         }
36.         else  // 如果是其它错误，返回失败。
37.         {
38.           perror("init 2 semget()"); return false;
39.         }
40.       }
42.       // 信号量创建成功后，还需要把它初始化成value。
43.       union semun sem_union;
44.       sem_union.val = value;   // 设置信号量的初始值。
45.       if (semctl(m_semid,0,SETVAL,sem_union) <  0)
46.       {
47.         perror("init semctl()"); return false;
48.       }
49.     }
50.     else
51.     { perror("init 3 semget()"); return false; }
52.   }
54.   return true;
55. }
57. // 信号量的P操作（把信号量的值减value），如果信号量的值是0，将阻塞等待，直到信号量的值大于0。
58. bool csemp::wait(short value)
59. {
60.   if (m_semid==-1) return false;
62.   struct sembuf sem_b;
63.   sem_b.sem_num = 0;      // 信号量编号，0代表第一个信号量。
64.   sem_b.sem_op = value;   // P操作的value必须小于0。
65.   sem_b.sem_flg = m_sem_flg;
66.   if (semop(m_semid,&sem_b,1) == -1) { perror("p semop()"); return false; }
68.   return true;
69. }
71. // 信号量的V操作（把信号量的值减value）。
72. bool csemp::post(short value)
73. {
74.   if (m_semid==-1) return false;
76.   struct sembuf sem_b;
77.   sem_b.sem_num = 0;     // 信号量编号，0代表第一个信号量。
78.   sem_b.sem_op = value;  // V操作的value必须大于0。
79.   sem_b.sem_flg = m_sem_flg;
80.   if (semop(m_semid,&sem_b,1) == -1) { perror("V semop()"); return false; }
82.   return true;
83. }
85. // 获取信号量的值，成功返回信号量的值，失败返回-1。
86. int csemp::getvalue()
87. {
88.   return semctl(m_semid,0,GETVAL);
89. }
91. // 销毁信号量。
92. bool csemp::destroy()
93. {
94.   if (m_semid==-1) return false;
96.   if (semctl(m_semid,0,IPC_RMID) == -1) { perror("destroy semctl()"); return false; }
98.   return true;
99. }
101. csemp::~csemp()
102. {
103. }

复制代码

测试步调3

1. // demo3.cpp，本程序演示用信号量给共享内存加锁。
2. #include "_public.h"
4. struct stgirl     // 超女结构体。
5. {
6.   int  no;        // 编号。
7.   char name[51];  // 姓名，注意，不能用string。
8. };
10. int main(int argc,char *argv[])
11. {
12.   if (argc!=3) { cout << "Using:./demo no name\n"; return -1; }
14.   // 第1步：创建/获取共享内存，键值key为0x5005，也可以用其它的值。
15.   int shmid=shmget(0x5005, sizeof(stgirl), 0640|IPC_CREAT);
16.   if ( shmid ==-1 )
17.   {
18.     cout << "shmget(0x5005) failed.\n"; return -1;
19.   }
21.   cout << "shmid=" << shmid << endl;
23.   // 第2步：把共享内存连接到当前进程的地址空间。
24.   stgirl *ptr=(stgirl *)shmat(shmid,0,0);
25.   if ( ptr==(void *)-1 )
26.   {
27.     cout << "shmat() failed\n"; return -1;
28.   }
30.   // 创建、初始化二元信号量。
31.   csemp mutex;
32.   if (mutex.init(0x5005)==false)
33.   {
34.     cout << "mutex.init(0x5005) failed.\n"; return -1;
35.   }
37.   cout << "申请加锁...\n";
38.   mutex.wait(); // 申请加锁。
39.   cout << "申请加锁成功。\n";
41.   // 第3步：使用共享内存，对共享内存进行读/写。
42.   cout << "原值：no=" << ptr->no << ",name=" << ptr->name << endl;  // 显示共享内存中的原值。
43.   ptr->no=atoi(argv[1]);        // 对超女结构体的no成员赋值。
44.   strcpy(ptr->name,argv[2]);    // 对超女结构体的name成员赋值。
45.   cout << "新值：no=" << ptr->no << ",name=" << ptr->name << endl;  // 显示共享内存中的当前值。
46.   sleep(10);
48.   mutex.post(); // 解锁。
49.   cout << "解锁。\n";
51.   // 查看信号量  ：ipcs -s    // 删除信号量  ：ipcrm sem 信号量id
52.   // 查看共享内存：ipcs -m    // 删除共享内存：ipcrm -m  共享内存id
54.   // 第4步：把共享内存从当前进程中分离。
55.   shmdt(ptr);
57.   // 第5步：删除共享内存。
58.   //if (shmctl(shmid,IPC_RMID,0)==-1)
59.   //{
60.    // cout << "shmctl failed\n"; return -1;
61.   //}
62. }

复制代码

输出

1. [root@localhost 07demosqueue]# ./demo3 3 冰冰
2. shmid=2
3. 申请加锁...
4. 申请加锁成功。
5. 原值：no=0,name=
6. 新值：no=3,name=冰冰
7. 解锁。

复制代码

---

11.多历程的生产消费者模型

1. //incache.cpp
2. // 多进程的生产消费者模型的生产者程序
3. #include "_public.h"
5. int main()
6. {
7.   struct stgirl  // 循环队列的数据元素是超女结构体。
8.   {
9.     int no;
10.     char name[51];
11.   };
13.   using ElemType=stgirl;
15.   // 初始化共享内存。
16.   int shmid=shmget(0x5005, sizeof(squeue<ElemType,5>), 0640|IPC_CREAT);
17.   if ( shmid ==-1 )
18.   {
19.     cout << "shmget(0x5005) failed.\n"; return -1;
20.   }
22.   // 把共享内存连接到当前进程的地址空间。
23.   squeue<ElemType,5> *QQ=(squeue<ElemType,5> *)shmat(shmid,0,0);
24.   if ( QQ==(void *)-1 )
25.   {
26.     cout << "shmat() failed\n"; return -1;
27.   }
29.   QQ->init();       // 初始化循环队列。
31.   ElemType ee;      // 创建一个数据元素。
33.   csemp mutex; mutex.init(0x5001);     // 用于给共享内存加锁。
34.   csemp cond;  cond.init(0x5002,0,0);  // 信号量的值用于表示队列中数据元素的个数。
36.   mutex.wait();  // 加锁。
37.   // 生产3个数据。
38.   ee.no=3; strcpy(ee.name,"西施"); QQ->push(ee);
39.   ee.no=7; strcpy(ee.name,"冰冰"); QQ->push(ee);
40.   ee.no=8; strcpy(ee.name,"幂幂"); QQ->push(ee);
41.   mutex.post();  // 解锁。
42.   cond.post(3);  // 实参是3，表示生产了3个数据。
44.   shmdt(QQ);  // 把共享内存从当前进程中分离。
45. }

复制代码

1. //outcache.cpp
2. // 多进程的生产消费者模型的消费者程序
3. #include "_public.h"
5. int main()
6. {
7.   struct stgirl  // 循环队列的数据元素是超女结构体。
8.   {
9.     int no;
10.     char name[51];
11.   };
13.   using ElemType=stgirl;
15.   // 初始化共享内存。
16.   int shmid=shmget(0x5005, sizeof(squeue<ElemType,5>), 0640|IPC_CREAT);
17.   if ( shmid ==-1 )
18.   {
19.     cout << "shmget(0x5005) failed.\n"; return -1;
20.   }
22.   // 把共享内存连接到当前进程的地址空间。
23.   squeue<ElemType,5> *QQ=(squeue<ElemType,5> *)shmat(shmid,0,0);
24.   if ( QQ==(void *)-1 )
25.   {
26.     cout << "shmat() failed\n"; return -1;
27.   }
29.   QQ->init();       // 初始化循环队列。
31.   ElemType ee;      // 创建一个数据元素。
33.   csemp mutex; mutex.init(0x5001);     // 用于给共享内存加锁。
34.   csemp cond;  cond.init(0x5002,0,0);  // 信号量的值用于表示队列中数据元素的个数。
36.   while (true)
37.   {
38.     mutex.wait();  // 加锁。
40.     while (QQ->empty())    // 如果队列空，进入循环，否则直接处理数据。必须用循环，不能用if
41.     {
42.       mutex.post();   // 解锁。
43.       cond.wait();    // 等待生产者的唤醒信号。
44.       mutex.wait();   // 加锁。
45.     }
47.     // 数据元素出队。
48.     ee = QQ->front();  QQ->pop();
49.     mutex.post(); // 解锁。
51.     // 处理出队的数据（把数据消费掉）。
52.     cout << "no=" << ee.no << ",name=" << ee.name << endl;
53.     usleep(100);    // 假设处理数据需要时间，方便演示。
54.   }
56.   shmdt(QQ);
57. }

复制代码

---

保举一个零声学院项目课，个人觉得老师讲得不错，分享给大家：
零声白金学习卡（含底子架构/高性能存储/golang云原生/音视频/Linux内核）
https://xxetb.xet.tech/s/3Zqhgt

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。