系统编程第三节——信号

最新推荐文章于 2024-09-04 23:01:27 发布
最新推荐文章于 2024-09-04 23:01:27 发布
阅读量280 收藏
点赞数
分类专栏： 嵌入式之系统编程 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lianggoch/article/details/118974139
版权

进程间通信 — 信号

1，Linux下的信号

信号机制是Linux系统内核管理任务的一种重要机制，信号传递的信息有限，所以都是表达一些特定意义，大部分的信号的默认功能都是让目标进程退出，暂停（SIGSTOP），继续（SIGCONT）。
1）Linux下的信号可以通过命令 kill -l 查看

一共是 62个信号。
前面的31个信号， 1~31
1、这些信号被称为非实时信号，也叫作不可靠信号
2、信号不会排队，但是会嵌套，如果有新的信号到达，但是原来的信号没有及时响应，前面的信号会被丢弃掉。
3、每一个信号对应一个事件，当这个事件发送的时候，系统就会给进程发送信号
4、如果进程挂起的信号中同时存在实时信号与非实时信号，进程会优先响应实时信号，实时信号的优先级从大到小。

后面31个信号，34~64
1、实时信号，也叫可靠信号
2、接受排队，不接受嵌套
3、如果同时发生多个相同的实时信号，只响应一次
4、实时信号没有具体的事件对应。

–》信号9 （SIGKILL）、 19（SIGSTOP）不允许被捕捉，忽略，阻塞的。

在这里插入图片描述

2）信号的发送
==> kill ==> kill -信号值 进程ID
==> killall ==> killall -信号值 进程名

==> kill() 发送信号的函数
函数的API
SYNOPSIS

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

==> pid : 目标进程的进程ID
==> sig : 信号值
返回值： 成功返回0，失败返回-1

练习1：父进程创建2个子进程，父进程3s之后发送3号信号给子进程1，5s之后发送1号信号给子进程2，父进程等待两个子进程都结束之后，父进程再结束。

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
/*父进程给两个子进程分别发送信号*/
int main(int argc, char *argv[])
{
	//1,父进程创建两个子进程
	pid_t pid1, pid2;
	pid1 = fork();  //创建进程
	if(pid1 > 0)	//父进程执行部分
	{
		pid2 = fork();  //创建进程
		if(pid2 > 0)	//父进程执行部分
		{
			sleep(3);   // 等待3S
			kill(pid1, 3);	//发送3号信号给子进程1
			printf("发送信号3给子进程1\n");
			sleep(2);
			kill(pid2, 1);	//发送1号信号给子进程2
			printf("发送信号1给子进程2\n");
			wait(NULL);
			wait(NULL);
			exit(0);     //退出进程
		}
		if(0 == pid2)	//子进程2执行部分
		{
			int time;
			for(time = 0; ; time++)
			{
				printf("child2: time:%d\n", time);
				sleep(1);
			}	
		}
	}
	if(0 == pid1)	//子进程1执行部分
	{
		while(1);
	}
	
	return 0;
}

关于参数pid的补充：
1、Pid > 0; 信号发送给进程号为pid的进程
2、Pid == 0; 信号发送给同一组内其他所有进程
3、Pid == -1; 信号发送给所有进程（当前进程具有权限发送的进程）
4、Pid < -1; 信号发送给进程组ID为pid绝对值的进程

发送成功返回0，失败返回-1，并且错误被设置
EINVAL ： 信号无效或不支持
EPERM ： 没有权限发送
ESRCH ：目标进程不存在

3、信号的捕捉 signal （）
==> 进程在接收到信号之后，如果没有特殊设置，会响应信号的默认动作，但是一些时候我们希望接收到信号之后不去响应退出，此时可以通过signal函数对信号进行捕捉，忽略。
·函数原型 signal

SYNOPSIS

   #include <signal.h>
   typedef void (*sighandler_t)(int);	//参数为int，返回值为void函数指针
   sighandler_t signal(int signum, sighandler_t handler);

==> signum : 要捕捉的信号值 （SIGKILL，SIGSTOP不能被捕捉）
==> handler : 捕捉到信号之后执行的动作
SIG_IGN ： 忽略这个信号
SIG_DFL ： 执行默认动作
Fun ： 自定义的函数指针 --> 捕捉到信号之后执行规定的动作

==> 例子： 设计程序。使用signal函数捕捉信号 ctrl + c （SIGINT），每次捕捉到信号，就打印一句话 ：”有话好好说!”

==> 练习2： 设计程序，父进程创建一个子进程，父进程使用signal函数捕捉信号1，每次捕捉到信号1就打印 “小样！”， 父进程循环打印时间，子进程3s之后给父进程发送一个信号1， 再等2s发送一个信号2，然后子进程退出。

4）alarm --> 给自己发送一个闹钟信号 SIGALRM
SYNOPSIS

   #include <unistd.h>

   unsigned int alarm(unsigned int seconds);

==> seconds : 时间（单位 秒）

==> 例子： 设计程序，每5秒钟打印一次helloworld.

2，信号集

1） 信号集的概念
Signal函数的功能是将信号捕捉，然后去执行特定的事件，或者是忽略，或者执行默认动作。而信号集的作用是把信号阻塞。
每一个进程都会有一个描述将来哪些信号会被阻塞的信号集，这个信号集也被成为信号掩码，当某一个信号在这个被阻塞的信号集 (sigset_t) 中，那么传送到该进程的这种信号会被阻塞。
创建子进程时，子进程会继承父进程的信号集。

2）信号忽略与信号阻塞的区别
阻塞： 操作系统在进程解除信号阻塞之前不会把信号传递出去，被阻塞的信号也不会影响进程的行为。
忽略：当进程忽略一个信号时，信号会被传递出去，但进程会把信号丢弃。

3）相关函数
SYNOPSIS 信号集操作概念函数

   #include <signal.h>

   int sigemptyset(sigset_t *set);		//清空信号集
   int sigfillset(sigset_t *set);		//把信号集填满
   int sigaddset(sigset_t *set, int signum);	//把信号添加到信号集
   int sigdelset(sigset_t *set, int signum);	//把信号移出信号集
   int sigismember(const sigset_t *set, int signum);	//判断信号是否在信号集中

SYNOPSIS 设置对信号集内的信号的处理方式

   #include <signal.h>

   int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

==> how : 对信号集中的信号的处理方式
SIG_BLOCK ： 在原来的基础上，添加参数set信号集中的信号
SIG_SETMASK ：将set中信号替换掉原来的信号
SIG_UNBLOCK ：在原来的基础上解除set里面的信号

==> set : 信号集变量的地址
==> oldset : 原来的信号集地址
返回值： 成功返回0，失败返回-1.

==》例子： 设计一个程序，把信号集添加 SIGHUP， SIGINT， SIGQUIT 信号添加阻塞，10s做自己的事情，10s之后解除阻塞。其他的进程这个过程中给这个进程发送 SIGHUP信号，

进程间通信 – System V IPC对象

1， System V IPC对象
System V IPC对象是Linux从Unix中继承过来的进程间通信方式。
最初进程间的通信主要是依赖信号与管道，但是这两种通信方式各有不足之处，随着系统发展，这些通信方式不太能满足通信需求。例如：无名管道只能实现亲缘进程之间的通信，有名管道传递的数据接收方只能有一个，不知道发送方是谁，信号传递的信息量太少…
为了解决这些问题，人们发明了IPC对象

2，IPC对象
IPC对象主要是指： 消息队列， 共享内存， 信号量
IPC对象不存在与Linux的文件系统中，它的唯一标识符是它的key值。通过key值来识别IPC对象，IPC对象除了key值之外，还有对应的ID，这个ID是我们操作IPC对象的句柄。

==> 注意： 每一个IPC对象的key值是唯一的，ID不是惟一的。
==> IPC对象会一直存在于Linux系统中，不会随着进程的结束而消失。

1)相关命令
Ipcs -a 查看当前系统中所有的IPC对象

------ Message Queues -------- //消息队列
key msqid owner perms used-bytes messages

------ Shared Memory Segments -------- //共享内存
key shmid owner perms bytes nattch status
0x00000000 393216 gec 600 524288 2 dest
0x00000000 1245185 gec 600 524288 2 dest
0x00000000 589826 gec 600 16777216 2
0x00000000 622595 gec 600 524288 2 dest
0x00000000 884740 gec 600 524288 2 dest
0x00000000 983045 gec 600 524288 2 dest
0x00000000 1081350 gec 600 524288 2 dest
0x00000000 1146887 gec 600 16777216 2 dest
0x00000000 1343496 gec 600 524288 2 dest
0x00000000 1605641 gec 600 524288 2 dest
0x00000000 1835019 gec 600 67108864 2 dest

------ Semaphore Arrays -------- //信号量
key semid owner perms nsems

==> 删除IPC对象 ipcrm
==> 删除消息队列 ： ipcrm -q msgid
==> 删除共享内存 ： ipcrm -m shmid
==> 删除信号量 ： pcrm -s semid

消息队列(类似于管道，消息是带有类型的)
在这里插入图片描述

2)相关函数
(1)获取IPC对象键值 key – ftok()
SYNOPSIS

   #include <sys/types.h>
   #include <sys/ipc.h>

   key_t ftok(const char *pathname, int proj_id);

==> pathname : 一个合法的路径 (路径要存在)
==> proj_id : 一个大于0的整数
==> 返回值： 成功返回键值，失败返回-1；

(2)获取消息队列的ID --> msgget()
SYNOPSIS

   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/msg.h>

   int msgget(key_t key, int msgflg);

==> key : IPC对象的key值
==> msgflg : 标志位
IPC_CREAT | 0666 ; 如果对象不存在则创建
IPC_EXCL 如果对象存在则报错
返回值： 成功返回消息队列的ID，失败返回-1

(3)收发消息 msgsnd, msgrcv,
SYNOPSIS

   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/msg.h>

   int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);		//发送消息

==> msqid : 消息队列的ID
==> msgp : 需要发送的消息
==> msgsz : 消息的大小
==> msgflg : 消息的标志，默认是0

   ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);	//接收

==> msqid : 消息队列的ID
==> msgp : 接收消息的缓冲区地址
==> msgsz : 消息的大小
==> msgtyp : 消息的类型
==> msgflg : 消息的标志，默认是0

消息结构体：

struct msgbuf {
long mtype; /* message type, must be > 0 / 消息类型
char mtext[1]; / message data */ //消息数据 ==> 自行设计大小
};

(4)消息队列的删除 msgctl
SYNOPSIS

   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/msg.h>

   int msgctl(int msqid, int cmd, struct msqid_ds *buf);

==> msqid : 消息队列ID
==> cmd : 操作命令 （IPC_RMID：删除IPC对象）
==> buf : 如果第二个参数选择IPC_RMID ,那第三个参数不要了

练习
1，理解消息队列单向通信功能代码，实现使用一个消息队列实现双向通信。
进程A 进程B
父进程A写入类型1的消息 子进程b读取类型1的消息
子进程a读取类型2的消息 父进程B写入类型2的消息

进程A端代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  10

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};

/*进程A*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	
	
	//3, 创建子进程 --> fork
	pid_t pid = fork();
	if(-1 == pid)
	{
		perror("fork failed");
		return -1;
	}	
	//父进程循环往消息队列发送类型为1的消息
	if(pid > 0)
	{
		for( ; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgp.mtype = MTYPE_1;	
			fgets(msgp.mtext, sizeof(msgp.mtext), stdin);	//scanf
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送消息			
		}
	}
	
	//子进程循环从消息队列中获取类型2的消息
	if(pid == 0)
	{
		for(; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_2, 0);	//接收消息
			printf("recv from rose : %s", msgp.mtext);		
		}

	}
	
	return 0;
}

进程B端代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  10

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};

/*进程B*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	
	
	//3, 创建子进程 --> fork
	pid_t pid = fork();
	if(-1 == pid)
	{
		perror("fork failed");
		return -1;
	}	
	//父进程循环往消息队列发送类型为2的消息
	if(pid > 0)
	{
		for( ; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgp.mtype = MTYPE_2;	
			fgets(msgp.mtext, sizeof(msgp.mtext), stdin);	//scanf
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送消息			
		}
	}
	
	//子进程循环从消息队列中获取类型1的消息
	if(pid == 0)
	{
		for(; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_1, 0);	//接收消息
			printf("recv from jack : %s", msgp.mtext);		
		}

	}
	
	return 0;
}

2，利用相关函数实现以下功能
父进程创建2个子进程。父进程循环打印时间。 alarm
父进程每隔5s打印”开饭了!”,并且给子进程发送信号，子进程接收到信号之后打印 “Child 1 process 吃饱了！”
“Child 2 process 吃饱了！”
或者
“Child 2 process 吃饱了！”
“Child 1 process 吃饱了！”
不断循环实现这个效果。

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

pid_t pid1, pid2;

void fun(int arg)
{
	printf("开饭了!\n");
	kill(pid1, SIGQUIT);
	kill(pid2, SIGQUIT);
	alarm(5);
}

void fun1(int arg)
{
	printf("Child 1 process 吃饱了!\n");
}

void fun2(int arg)
{
	printf("Child 2 process 吃饱了!\n");
}

/*父进程循环给子进程喂饭*/
int main(int argc, char *argv[])
{
	//1,创建2条子进程
	pid1 = fork();
	if(-1 == pid1)
	{	
		perror("fork 1 failed");
		return -1;
	}
	if(0 == pid1)	//子进程1 子进程1与子进程2循环等待父进程的信号
	{
		signal(SIGQUIT, fun1);
		while(1)
			pause();
	}
	if(0 < pid1)	//父进程
	{
		pid2 = fork();
		if(-1 == pid2)
		{	
			perror("fork 2 failed");
			return -1;
		}		
		if(0 == pid2)	//子进程2
		{
			signal(SIGQUIT, fun2);
			while(1)
				pause();
		}
		if(0 < pid2)	//父进程	//2,父进程注册捕捉信号 SIGALRM //3,父进程循环打印时间
		{
			signal(SIGALRM, fun);
			alarm(5);
			for(int i = 0; ; i++)
			{
				printf("time : %d\n", i);
				sleep(1);
			}
			wait(NULL);
			wait(NULL);
		}		
		
	}
	

	return 0;
}

3，-- 使用消息队列实现一个服务器转发功能
实现思路： 服务器循环从消息队列中接收类型1的消息。接收到消息就输出。
进程A的父进程A循环发送类型为1的消息，子进程a循环接收类型为2的消息，接收到就打印。
进程B的父进程B循环发送类型为1的消息，子进程B循环接收类型为3的消息，接收到就打印。
进程C的父进程C循环发送类型为1的消息，子进程c循环接收类型为4的消息，接收到就打印。
进程A，B，C任何一个想要发送广播数据（服务器转发给其他进程），那就给服务器发送类型为”BoardCast:xxxxx”；的数据，如果服务器接收到这种数据，那就把这个数据转发给进程A, B, C
进程A

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  100

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define MTYPE_3  3		//消息类型3
#define MTYPE_4  4		//消息类型4

#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};

/*进程A*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	
	
	//3, 创建子进程 --> fork
	pid_t pid = fork();
	if(-1 == pid)
	{
		perror("fork failed");
		return -1;
	}	
	//父进程循环往消息队列发送类型为1的消息
	if(pid > 0)
	{
		for( ; ; )
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgp.mtype = MTYPE_1;	
			fgets(msgp.mtext, sizeof(msgp.mtext), stdin);	//scanf
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送消息			
		}
	}
	
	//子进程循环从消息队列中获取类型2的消息
	if(pid == 0)
	{
		for(; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_2, 0);	//接收消息
			printf("%s", msgp.mtext);		
		}

	}
	
	return 0;
}

进程B

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  100

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define MTYPE_3  3		//消息类型3
#define MTYPE_4  4		//消息类型4

#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};

/*进程B*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	
	
	//3, 创建子进程 --> fork
	pid_t pid = fork();
	if(-1 == pid)
	{
		perror("fork failed");
		return -1;
	}	
	//父进程循环往消息队列发送类型为1的消息
	if(pid > 0)
	{
		for( ; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgp.mtype = MTYPE_1;	
			fgets(msgp.mtext, sizeof(msgp.mtext), stdin);	//scanf
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送消息			
		}
	}
	
	//子进程循环从消息队列中获取类型3的消息
	if(pid == 0)
	{
		for(; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_3, 0);	//接收消息
			printf("%s", msgp.mtext);		
		}

	}
	
	return 0;
}

进程C

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  100

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define MTYPE_3  3		//消息类型3
#define MTYPE_4  4		//消息类型4

#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};

/*进程C*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	
	
	//3, 创建子进程 --> fork
	pid_t pid = fork();
	if(-1 == pid)
	{
		perror("fork failed");
		return -1;
	}	
	//父进程循环往消息队列发送类型为1的消息
	if(pid > 0)
	{
		for( ; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgp.mtype = MTYPE_1;	
			fgets(msgp.mtext, sizeof(msgp.mtext), stdin);	//scanf
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送消息			
		}
	}
	
	//子进程循环从消息队列中获取类型4的消息
	if(pid == 0)
	{
		for(; ;)
		{
			memset(msgp.mtext, 0, sizeof(msgp.mtext));
			msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_4, 0);	//接收消息
			printf("%s", msgp.mtext);		
		}

	}
	
	return 0;
}

消息队列服务器

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define MSQ_PATH "."
#define PROJ_ID  100

#define MTYPE_1  1		//消息类型1
#define MTYPE_2  2		//消息类型2
#define MTYPE_3  3		//消息类型3
#define MTYPE_4  4		//消息类型4

#define BUF_SIZE 1024

struct msgbuf {
	long mtype;       /* message type, must be > 0 */ //消息类型
	char mtext[BUF_SIZE];    /* message data */		//消息数据 ==> 自行设计大小
};


/*消息队列服务器*/
int main(int argc, char *argv[])
{
	struct msgbuf msgp;		//消息缓冲区
	
	//1, 获取消息队列key值
	key_t key = ftok(MSQ_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取消息队列操作ID
	int msqid = msgget(key, IPC_CREAT | 0666);
	if(-1 == msqid)
	{
		perror("msgget failed");
		return -1;
	}	

	//3,循环接收类型为1的消息,如果接收到以"BoardCast:"开头的消息，就转发给所有客户端
	for( ; ; )
	{
		memset(msgp.mtext, 0, sizeof(msgp.mtext));
		msgrcv(msqid, &msgp, sizeof(msgp.mtext), MTYPE_1, 0);	//接收消息
		printf("recv msg : %s", msgp.mtext);
		if( strncmp("BoardCast:", msgp.mtext, 10) == 0)	//如果按照广播格式发送消息到服务器,那就转发
		{
			msgp.mtype = MTYPE_2;	
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送类型2消息		

			msgp.mtype = MTYPE_3;	
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送类型3消息
			
			msgp.mtype = MTYPE_4;	
			msgsnd(msqid, &msgp, sizeof(msgp.mtext), 0);	//发送类型4消息
		}
		
	}
	
	
	
	
	return 0;
}

例程：父进程给两个子进程分别发送信号

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
/*父进程给两个子进程分别发送信号*/
int main(int argc, char *argv[])
{
	//1,父进程创建两个子进程
	pid_t pid1, pid2;
	pid1 = fork();  //创建进程
	if(pid1 > 0)	//父进程执行部分
	{
		pid2 = fork();  //创建进程
		if(pid2 > 0)	//父进程执行部分
		{
			sleep(3);   // 等待3S
			kill(pid1, 3);	//发送3号信号给子进程1
			printf("发送信号3给子进程1\n");
			sleep(2);
			kill(pid2, 1);	//发送1号信号给子进程2
			printf("发送信号1给子进程2\n");
			wait(NULL);
			wait(NULL);
			exit(0);     //退出进程
		}
		if(0 == pid2)	//子进程2执行部分
		{
			int time;
			for(time = 0; ; time++)
			{
				printf("child2: time:%d\n", time);
				sleep(1);
			}	
		}
	}
	if(0 == pid1)	//子进程1执行部分
	{
		while(1);
	}
	
	return 0;
}

例程：创建两个进程，父进程等待一个信号，如果父进程接收到信号就触发函数

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

pid_t pid1, pid2;

void fun(int arg)	//父进程信号触发函数
{
	kill(pid1, SIGHUP);		//给子进程1发送信号
	kill(pid2, SIGHUP);		//给子进程2发送信号
}

void fun1(int arg)
{
	printf("Child process 1 is killed by parent!\n");
}

void fun2(int arg)
{
	printf("Child process 2 is killed by parent!\n");
}


int main(int argc, char *argv[])
{
	//1,父进程创建两个子进程
	pid1 = fork();
	if(pid1 > 0)	//父进程
	{
		pid2 = fork();
		if(pid2 > 0)	//父进程
		{
			signal(SIGINT, fun);
			pause();	//挂起等待一个信号
			wait(NULL);
			wait(NULL);
			printf("Parent process exit!\n");
		}
		if(pid2 == 0)	//子进程2
		{
			signal(SIGHUP, fun2);
			pause();	
		}
		
	}
	if(pid1 == 0)	//子进程1
	{
		signal(SIGHUP, fun1);
		pause();	
	}
	
	return 0;
}
qmy_lhl
关注
专栏目录
【并发编程六】c++进程通信——信号量（semaphore)
junxuezheng的博客
11-17 7844
信号量是操作系统提供的一种协调共享资源访问的方法。信号量则由操作系统进行管理，地位高于进程，操作系统保证信号量的原子性。
信号与系统 matlab综合实验 pdf,《信号与系统——MATLAB综合实验》 谷源涛-第三讲.pdf...
weixin_35006433的博客
03-17 1205
学编程 学应用谷源涛清华大学电子工程系课程内容2008-8-14 谷源涛@清华大学电子工程系 27. 离散时间系统的时域分析常系数线性差分方程的求解离散时间系统的单位样值(单位冲激)响应卷积(卷积和)解卷积(反卷积)2008-8-14 谷源涛@清华大学...
【笔记汇总】操作系统
FMatch的博客
07-12 272
进程、线程、协程 （1）基础概念 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的...
系统编程之信号篇
bluzelee2011的专栏
08-22 677
信号（一） 一、kill –l产看所有的信号名，man 7 signal查看信号名及解释，man signal查看signal函数 二、中断分类 q 硬件中断（外部中断）          外部中断是指由外部设备通过硬件请求的方式产生的中断，也称为硬件中断 q 软件中断（内部中断）          内部中断是由CPU运行程序错误或执行内部程序调用引起的一种中断，也称为软件中断
系统编程--信号
最新发布
长安1108的博客
09-04 228
注意：所有信号的产生及其处理都是内核完成，所以，后续我们做的任何有关信号的代码操作，都不是我们直接去创建一个信号，或者操作一个信号，而是驱使内核去创建、操作信号。
操作系统与系统编程（3）——信号
WSTONECH的博客
03-10 838
信号 信号原语 配置信号的handel
linux 系统编程之-信号
王道长的技术博客
05-04 1040
文章目录第一章 信号的概念信号的机制与信号相关的事件和状态信号的编号信号4要素Linux常规信号一览表第二章 信号的产生终端按键产生信号硬件异常产生信号kill函数/命令产生信号raise和abort函数软件条件产生信号setitimer函数第三章 信号集操作函数信号集设定sigprocmask函数sigpending函数第四章 信号捕捉signal函数信号捕捉特性内核实现信号捕捉过程：第五章 竞...
《在系统可编程技术应用设计&SOPC技术及应用》——第5讲 VHDL顺序语句.ppt
05-07
VHDL，全称Very High Speed Integrated Circuit Hardware Description Language，是一种用于数字电子系统设计的硬件描述语言，广泛应用于系统级可编程技术应用设计和SOPC（System on a Programmable Chip，可编程片...
电力拖动自动控制系统——运动控制系统（第五版阮毅等）课后题习题答案
06-24
在《电力拖动自动控制系统——运动控制系统（第五版）》一书中，阮毅等作者深入探讨了这一领域的核心理论与实践应用。这本书的课后习题答案提供了对教材内容的深度理解和巩固，对于学习者来说是一份宝贵的参考资料。...
2016_第七届_蓝桥杯_省赛——“模拟风扇控制系统"
03-06
【标题】2016_第七届_蓝桥杯_省赛——“模拟风扇控制系统” 【描述】本项目涉及的是在2016年的第七届蓝桥杯省赛中的一项竞赛任务，即“模拟风扇控制系统”。该比赛主要考察参赛者在单片机设计与开发领域的技能，...
系统编程-信号？
Liangsm_的博客
11-14 426
#include "io.h"static int varArray[10]; /*初始化了（static）*/void set(int * array, int value) { int i = 0; for (; i < 10; i++) { array[i] = value; sleep(1); } } void sighandl
Linux系统编程——信号
weixin_54794458的博客
08-16 461
Linux 信号
03-系统编程（信号）
2301_79475863的博客
09-17 71
Linux系统编程信号
Linux系统编程Day07
weixin_46412362的博客
03-11 131
1.匿名映射实现父子进程通信 通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也 较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。 通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较 麻烦。 可以直接使用匿名映射来代替。 其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建 映射区。同样需要借助标志位参数flags来指定。 使用MAP_ANONYMOUS (或MAP_ANON)。 int *p =
信号编程
weixin_41679960的博客
03-24 100
信号接受函数 #include<signal.h> #include<stdio.h> #include <unistd.h> //typedef void (*sighandler_t)(int); void handler(int signum){ switch(signum){ case SIGIO: printf("SIGIO signal: %d\n", signum); case SIGUSR1: printf("SIGUSR1
linux系统编程--信号
weixin_45639955的博客
02-20 305
1概念 1.1特点 简单 携带信息量少 使用在某个特定的场景中（） 1.2信号的状态 产生 键盘：ctrl+c 命令：kill 系统函数：kill 软体件：定时器 硬件错误：段错误 未决状态（没有被处理了，等待被处理） 递达（信号被处理了） 状态关系图 信号流程图 1.3处理方式 忽略 捕捉 执行默认处理 1.4信号4要素 编号 信号 对应的事件 默认动作 信号有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值