Linux系统编程之进程间通信（IPC多种通信方式API）

一、进程间通信（IPC）简介
二、无名管道pipe和命名管道mkfifo
三、消息队列msgget、msgsnd、msgrcv、msgctl及frok
四、共享内存shmget、shmat、shmdt、shmctl
五、信号signal、sigaction、kill、sigqueue
六、信号量semget、semop、semctl

一、进程间通信（IPC）简介

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。

IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。

以Linux中的C语言编程为例。

二、无名管道pipe和命名管道mkfifo

一、管道
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。

1、特点：

• 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
• 它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
• 它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write
  等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

同一时间数据只能是单向的（一个读一个写，不能一起读或者一起写）
管道中的数据，读完就不存在了（管道中间不储存数据）

2、原型：

#include <unistd.h>

	struct fd_pair pipe();
	int pipe(int pipefd[2]);				// 返回值：若成功返回0，失败返回-1
	int pipe2(int pipefd[2], int flags);

当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：

要关闭管道只需将这两个文件描述符关闭即可。

3、例子
单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：


若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。

//pipe.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

//函数原型int pipe(int pipefd[2]);

int main()
{
	int fd[2];  // 两个文件描述符
	pid_t pid;
	char buf[128];

	if(pipe(fd) == -1){  // 创建管道 返回值：若成功返回0，失败返回-1
		printf("Create Pipe Error!\n");
	}
	pid = fork();// 创建子进程

	if(pid < 0){
		printf("Fork Error!\n");
	}
	else if(pid > 0)  // 父进程
	{
		sleep(3);
		printf("parent process\n");

		close(fd[0]); // 关闭读端
		write(fd[1], "hello from parent\n", strlen("hello form parent"));
		wait(NULL);
	}
	else
	{
		printf("child process\n");

		close(fd[1]); // 关闭写端
		read(fd[0], buf, 128);
		printf("read from parent:%s\n", buf);
		exit(0);
	}

	return 0;
}

二、FIFO
FIFO，也称为命名管道，它是一种文件类型。

1、特点

• FIFO可以在无关的进程之间交换数据，与无名管道不同。
• FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2、原型

#include <sys/stat.h>

	int mkfifo(const char *pathname, mode_t mode);// 返回值：成功返回0，出错返回-1

其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

• 若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
• 若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

3、例子
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”。下面的例子演示了使用 FIFO 进行 IPC 的过程：

写FIFO

//fifo_w.c
#include <stdio.h>
#include <stdlib.h>   // exit
#include <fcntl.h>    // O_WRONLY
#include <time.h>     // time
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

int main()
{
    int fd;
    int n, i;
    char buf[1024];
    time_t tp;

    printf("I am %d process.\n", getpid()); // 说明进程ID

    if((fd = open("fifo1", O_WRONLY)) < 0) // 以写打开一个FIFO
    {
        perror("Open FIFO Failed");
        exit(1);
    }

    for(i=0; i<10; ++i)
    {
        time(&tp);  // 取系统当前时间
        n=sprintf(buf,"Process %d's time is %s",getpid(),ctime(&tp));
        printf("Send message: %s", buf); // 打印
        if(write(fd, buf, n+1) < 0)  // 写入到FIFO中
        {
            perror("Write FIFO Failed");
            close(fd);
            exit(1);
        }
        sleep(1);  // 休眠1秒
    }

    close(fd);  // 关闭FIFO文件
    return 0;
}

读FIFO

//fifo_r.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

int main()
{
    int fd;
    int len;
    char buf[1024];

    if(mkfifo("fifo1", 0666) < 0 && errno!=EEXIST) // 创建FIFO管道
        perror("Create FIFO Failed");

    if((fd = open("fifo1", O_RDONLY)) < 0)  // 以读打开FIFO
    {
        perror("Open FIFO Failed");
        exit(1);
    }

    while((len = read(fd, buf, 1024)) > 0) // 读取FIFO管道
        printf("Read message: %s", buf);

    close(fd);  // 关闭FIFO文件
    return 0;
}

在两个终端里用 gcc 分别编译运行上面两个文件，可以看到输出结果如下：

上述例子可以扩展成 客户进程—服务器进程 通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：

my_fifo

//write.c
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
//int mkfifo(const char *pathname, mode_t mode);

int main()
{
	int cnt = 0;
	char *str = "message from fifo";

	int fd = open("./file", O_WRONLY);
	printf("write open success\n");

	while (1){
		write(fd, str, strlen(str));
		sleep(1);
		if (cnt == 5){
			break;
		}
	}
	close(fd);

	return 0;
}

//read.c
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
//int mkfifo(const char *pathname, mode_t mode);

int main()
{
	char buf[30] = {0};
	int n_read = 0;

	if ((mkfifo("./file", 0600) == -1) && errno != EEXIST){
		printf("mkfifo failure\n");
		perror("why Error");
	}

	int fd = open("./file", O_RDONLY);
	printf("open success\n");

	while (1){
		n_read = read(fd, buf, 30);
		printf("read %d byte from fifo,context:%s\n", n_read, buf);
	}	
	close(fd);

	return 0;
}

运行结果

三、消息队列msgget、msgsnd、msgrcv、msgctl及frok

消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。

1、特点

• 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
• 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
• 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

2、原型

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

// 创建或打开消息队列：成功返回队列ID，失败返回-1
int msgget(key_t key, int flag);
// 添加消息：成功返回0，失败返回-1
int msgsnd(int msqid, const void *ptr, size_t size, int flag);
// 读取消息：成功返回消息数据的长度，失败返回-1
int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
// 控制消息队列：成功返回0，失败返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

在以下两种情况下，msgget将创建一个新的消息队列：

• 如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
• key参数为IPC_PRIVATE。

函数msgrcv在读取消息队列时，type参数有下面几种情况：

• type == 0，返回队列中的第一个消息；
• type > 0，返回队列中消息类型为 type 的第一个消息；
• type < 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。

可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。（其他的参数解释，请自行Google之）

3、例子
下面写了一个简单的使用消息队列进行IPC的例子，服务端程序一直在等待特定类型的消息，当收到该类型的消息以后，发送另一种特定类型的消息作为反馈，客户端读取该反馈并打印出来。

消息服务器

//msg_server.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

// 用于创建一个唯一的key
#define MSG_FILE "/etc/passwd"

// 消息结构
struct msg_form {
    long mtype;
    char mtext[256];
};

int main()
{
    int msgid;
    key_t key;
    struct msg_form msg;

    // 获取key值
    if ((key = ftok(MSG_FILE, 'z')) < 0)
    {
        perror("ftok Error");
        exit(1);
    }

    // 打印key值
    printf("Message Queue - Server key is: %d.\n", key);

    // 创建消息队列
    if ((msgid = msgget(key, IPC_CREAT|0777)) == -1)
    {
        perror("msgget Error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msqid is: %d.\n", msgid);
    printf("My pid is: %d.\n", getpid());

    // 循环读取消息
	for (;;)
    {
		msgrcv(msgid, &msg, 256, 888, 0);// 返回类型为888的第一个消息
		printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
        printf("Server: receive msg.mtype is: %ld.\n", msg.mtype);

        msg.mtype = 999; // 客户端接收的消息类型
        sprintf(msg.mtext, "hello, I'm server %d", getpid());
        msgsnd(msgid, &msg, sizeof(msg.mtext), 0);
    }
    
    // 命令删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

消息客户端

//msg_client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>

// 用于创建一个唯一的key
#define MSG_FILE "/etc/passwd"

// 消息结构
struct msg_form {
    long mtype;
    char mtext[256];
};

int main()
{
    int msgid;
    key_t key;
    struct msg_form msg;

    // 获取key值
    if ((key = ftok(MSG_FILE, 'z')) < 0)
    {
        perror("ftok Error");
        exit(1);
    }

    // 打印key值
    printf("Message Queue - Client key is: %d.\n", key);

    // 打开消息队列
    if ((msgid = msgget(key, IPC_CREAT|0777)) == -1)
    {
        perror("msgget Error");
        exit(1);
    }

    // 打印消息队列ID及进程ID
    printf("My msgid is: %d.\n", msgid);
    printf("My pid is: %d.\n", getpid());

    // 添加消息，类型为888
    msg.mtype = 888;
    sprintf(msg.mtext, "hello, I'm client %d", getpid());
    msgsnd(msgid, &msg, sizeof(msg.mtext), 0);

    // 读取类型为777的消息
    msgrcv(msgid, &msg, 256, 999, 0);
    printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
    printf("Client: receive msg.mtype is: %ld.\n", msg.mtype);

    // 命令删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

运行结果

ftok函数

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

	key_t ftok( const char * fname, int id )

fname就是你指定的文件名（已经存在的文件名），一般使用当前目录，如：
key_t key;
key = ftok(“.”, 1); 这样就是将fname设为当前目录。
id是子序号。虽然是int类型，但是只使用8bits（1-255）。
在一般的UNIX实现中，是将文件的索引节点号取出，前面加上子序号得到key_t的返回值。
如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key_t返回值为0x26010002。

查询文件索引节点号的方法是： ls -i

当删除重建文件后，索引节点号由操作系统根据当时文件系统的使用情况分配，因此与原来不同，所以得到的索引节点号也不同。
如果要确保key_t值不变，要么确保ftok的文件不被删除，要么不用ftok，指定一个固定的key_t值，比如:

#define IPCKEY 0x111
char path[256];
sprintf( path, "%s/etc/config.ini", (char*)getenv("HOME") );
msgid=ftok( path, IPCKEY );[/code]

同一段程序，用于保证两个不同用户下的两组相同程序获得互不干扰的IPC键值。
由于etc/config.ini（假定）为应用系统的关键配置文件，因此不存在被轻易删除的问题——即使被删，也会很快被发现并重建（此时应用系统也将被重启）。
ftok( )的设计目的也在于此。

msgctl函数

调用原型：

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

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

返回值：

• 0 ，如果成功。
• -1，如果失败：errno = EACCES (没有读的权限同时cmd 是IPC_STAT )
• EFAULT (buf 指向的地址无效)
• EIDRM (在读取中队列被删除)
• EINVAL (msgqid无效, 或者msgsz 小于0 )
• EPERM (IPC_SET或者IPC_RMID 命令被使用，但调用程序没有写的权限)

使用命令：

• IPC_STAT
  读取消息队列的数据结构msqid_ds，并将其存储在b u f指定的地址中。
• IPC_SET
  设置消息队列的数据结构msqid_ds中的ipc_perm元素的值。这个值取自buf参数。
• IPC_RMID

从系统内核中移走消息队列。

我们在前面讨论过了消息队列的数据结构(msqid_ds)。系统内核中为系统中的每一个消息队列保存一个此数据结构的实例。通过使用IPC_STAT命令，我们可以得到一个此数据结构的副本。

下面的程序就是实现此函数的过程：

int get_queue_ds( int qid, struct msgqid_ds *qbuf )
{
	if (msgctl(qid, IPC_STAT, qbuf) == -1){
		return(-1);
	}
		return(0);
	}
}

如果不能复制内部缓冲区，调用进程将返回-1。如果调用成功，则返回0。缓冲区中应该包括消息队列中的数据结构。
消息队列中的数据结构中唯一可以改动的元素就是ipc_perm。它包括队列的存取权限和关于队列创建者和拥有者的信息。你可以改变用户的id、用户的组id以及消息队列的存取权限。

下面是一个修改队列存取模式的程序：

int change_queue_mode(int qid, char *mode )
{
	struct msqid_ds tmpbuf;
/* Retrieve a current copy of the internal data structure */
	get_queue_ds(qid, &tmpbuf);
/* Change the permissions using an old trick */
	sscanf(mode, "%ho", &tmpbuf.msg_perm.mode);
/* Update the internal data structure */
	if (msgctl(qid, IPC_SET, &tmpbuf) == -1){
	return(-1);
	}
	return(0);
} 

我们通过调用get_queue_ds来读取队列的内部数据结构。然后，我们调用sscanf( )修改数据结构msg_perm中的mode 成员的值。但直到调用msgctl（）时，权限的改变才真正完成。在这里msgctl（）使用的是IPC_SET命令。

最后，我们使用系统调用msgctl ( )中的IPC_RMID命令删除消息队列：

int remove_queue(int qid )
{
	if (msgctl(qid, IPC_RMID, 0) == -1){
		return(-1);
	}
	else { 
		return(0);
	}
};

四、共享内存shmget、shmat、shmdt、shmctl

共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。

1、特点

1. 共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

2. 因为多个进程可以同时操作，所以需要进行同步。

3. 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

2、原型

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

// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接：成功返回0，失败返回-1
int shmdt(void *addr);
// 控制共享内存的相关信息：成功返回0，失败返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。

shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。

shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。

共享内存的接口函数以及指令

1.查看系统中的共享存储段

ipcs -m

2.删除系统中的共享存储段

ipcrm -m [shmid]

3.shmget ( )：创建共享内存

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

[参数key]：由ftok生成的key标识，标识系统的唯一IPC资源。

[参数size]：需要申请共享内存的大小。在操作系统中，申请内存的最小单位为页，一页是4k字节，为了避免内存碎片，我们一般申请的内存大小为页的整数倍。

[参数shmflg]：如果要创建新的共享内存，需要使用IPC_CREAT，IPC_EXCL，如果是已经存在的，可以使用IPC_CREAT或直接传0。

[返回值]：成功时返回一个新建或已经存在的的共享内存标识符，取决于shmflg的参数。失败返回-1并设置错误码。

4.shmat ( )：挂接共享内存

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

[参数shmid]：共享存储段的标识符。

[参数*shmaddr]：shmaddr = 0，则存储段连接到由内核选择的第一个可以地址上（推荐使用）。

[参数shmflg]：若指定了SHM_RDONLY位，则以只读方式连接此段，否则以读写方式连接此段。

[返回值]：成功返回共享存储段的指针（虚拟地址），并且内核将使其与该共享存储段相关的shmid_ds结构中的shm_nattch计数器加1（类似于引用计数）；出错返回-1。

5.shmdt ( )：去关联共享内存

当一个进程不需要共享内存的时候，就需要去关联。该函数并不删除所指定的共享内存区，而是将之前用shmat函数连接好的共享内存区脱离目前的进程。

int shmdt(const void *shmaddr);

[参数*shmaddr]：连接以后返回的地址。

[返回值]：成功返回0，并将shmid_ds结构体中的 shm_nattch计数器减1；出错返回-1。

6.shmctl ( )：销毁共享内存

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

[参数shmid]：共享存储段标识符。

[参数cmd]：指定的执行操作，设置为IPC_RMID时表示可以删除共享内存。

[参数*buf]：设置为NULL即可。

[返回值]：成功返回0，失败返回-1。

API调用

//shm_w.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
// int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
// void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接：成功返回0，失败返回-1
// int shmdt(void *addr);
// 控制共享内存的相关信息：成功返回0，失败返回-1
// int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

int main()
{
	
	int shmid;
	char *shmaddr;

	
	key_t key;
	key = ftok(".", 1);
	
	shmid = shmget(key, 1024*4, IPC_CREAT|0666);
	if (shmid == -1){
		printf("shmget noOk\n");
		exit(-1);
	}
	shmaddr = shmat(shmid, 0, 0);

	printf("shmat ok\n");
	strcpy(shmaddr, "chenlichen");

	sleep(5);
	shmdt(shmaddr);
	shmctl(shmid, IPC_RMID, 0);

	printf("quit\n");
	
	return 0;
}

//shm_r.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
// int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
// void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接：成功返回0，失败返回-1
// int shmdt(void *addr);
// 控制共享内存的相关信息：成功返回0，失败返回-1
// int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

int main()
{	
	int shmid;
	char *shmaddr;

	key_t key;
	key = ftok(".", 1);
	
	shmid = shmget(key, 1024*4, 0);
	if (shmid == -1){
		printf("shmget noOk\n");
		exit(-1);
	}
	shmaddr = shmat(shmid, 0, 0);

	printf("shmat ok\n");
	printf("data: %s\n:", shmaddr);

	shmdt(shmaddr);

	printf("quit\n");
	
	return 0;
}

运行结果## ipcs命令

1 ipcs -a  是默认的输出信息 打印出当前系统中所有的进程间通信方式的信息
2 ipcs -m  打印出使用共享内存进行进程间通信的信息
3 ipcs -q   打印出使用消息队列进行进程间通信的信息
4 ipcs -s  打印出使用信号进行进程间通信的信息

五、信号signal、sigaction、kill、sigqueue

1、信号简介

信号是进程之间互相传递消息的一种方法，信号全称为软中断信号，也可称为软中断，它是实现IPC的方法之一。

信号是UNIX和Linux系统响应某些条件而产生的一个事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。

注:信号只是简单用来通知某进程发生了什么事件，并不给该进程传递任何数据。

信号是由于某些错误条件而生成的，如内存段冲突、浮点处理错误或非法指令等。它们由shell和终端处理器生成来引起中断，可以作为在进程间传递消息或修改行为的一种方式，明确地由一个进程发送给另一个进程。无论何种情况，它们的编程接口都是相同的。

信号可以生成、捕获、响应或忽略。 用术语生成(raise)表示一个信号的产生,用术语捕获(catch)表示接收到一个信号。接收到该信号的进程会采取相应地处理，具体处理方法可以分为三种：

• 第一种方法： 类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处理。
• 第二种方法： 忽略某个信号，对该信号不做任何处理，就像未发生过一样。
• 第三种方法： 对该信号的处理保留系统的默认值，这是缺省操作。对大部分的信号的缺省操作是使得进程终止。进程通过系统调用signal
  来指定进程对某个信号的处理行为。

信号的名称在头文件signal.h中定义。它们以SIG开头，下图是系统支持的所有信号种类：

信号的名称

kill -l

在Unix和Linux系统中，信号是由整数值来标识的，而不是名称。不过，这些整数值通常以 SIG 前缀的方式来命名，以表示它们的含义。以下是一些常见的信号及其对应的含义：

1. SIGINT (2)：中断信号。通常由用户按下 CTRL+C 来中断当前正在运行的进程。

2. SIGQUIT (3)：退出信号。类似于 SIGINT，但在进程退出时产生一个核心转储（core dump）文件。

3. SIGILL (4)：非法指令信号。表示进程执行了非法指令。

4. SIGABRT (6)：终止信号。通常由进程自己发出，表示出现了严重错误，例如调用 abort() 函数。

5. SIGFPE (8)：浮点异常信号。表示进程执行了浮点数计算中的非法操作，如除以零或溢出。

6. SIGKILL (9)：强制终止信号。不可捕获，用于强制终止进程。

7. SIGSEGV (11)：段错误信号。表示进程尝试访问未分配的内存或越界访问内存。

8. SIGPIPE (13)：管道破裂信号。当一个进程尝试向一个已关闭的管道写入数据时产生。

9. SIGALRM (14)：闹钟信号。通常用于定时操作。

10. SIGTERM (15)：终止信号。通常用于请求进程正常退出。

11. SIGCHLD (17)：子进程状态改变信号。父进程收到此信号通常表示一个子进程已经终止。

12. SIGHUP (1)：挂起信号。通常用于通知进程重新加载配置文件。

这些是一些常见的信号及其含义。还有其他信号，每个Unix系统都可能具有不同的信号。在编程中，可以使用 man 命令或 kill -l 命令来查看系统上支持的信号列表及其含义。

Ctrl+C组合键: 默认情况下向前台进程发送SIGINT信号，这将引起该进程的终止，除非它事先安排了捕获这个信号。
kill命令 : 如果想发送一个信号给进程，而该进程并不是当前的前台进程，可以使用kill命令。该命令需要有一个可选的信号代码或信号名称和一个需要接收信号的目标进程PID。

	kill -HUP 512 向一个运行在另一个终端上的PID为512的进程发送“挂断”信号。

xkill命令： 可以向运行着某一命令的所有进程发送信号。

	xkillall -HUP inetd 通知inete程序重新读取它的配置选项。

**Ctrl + \ 组合键：**默认情况下会产生SIGQUIT信号。

注:系统对信号的响应视具体实现情况而定。如果进程接收到这些信号中的一个，但事先没有安排捕获它，进程将会终止。通常系统将生成核心转储文件core,并将其放在当前目录下。core文件是进程在内存中的映像，它对程序的调试很有用。

2、信号的处理：

信号的处理有三种方法，分别是：忽略、捕捉和默认动作

忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景
捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核。当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。
在此，我就不详细展开了，需要查看的，可以自行查看。也可以参考 《UNIX 环境高级编程（第三部）》的 P251——P256中间对于每个信号有详细的说明。

3、signal、sigaction、kill、sigqueue函数API

这些函数和系统调用在Unix/Linux中用于信号处理和发送信号，它们在进程间通信和处理外部事件中非常有用。以下是对这些函数和系统调用的详细介绍：

信号处理函数的注册signal、sigaction

信号处理发送函数kill、sigqueue

1. signal 函数

signal 函数：
如果系统通过 ctrl+c 产生了一个 SIGINT（中断信号），显然不是所有程序同时结束，那么，信号一定需要有一个接收者。对于处理信号的程序来说，接收者就是自己。

开始的时候，先来看看入门版本的信号注册函数，他的函数原型如下：

#include <signal.h>

typedef void (*sighandler_t)(int);

	sighandler_t signal(int signum, sighandler_t handler);

根据函数原型可以看出由两部分组成，一个是真实处理信号的函数，另一个是注册函数了。
对于sighandler_t signal(int signum, sighandler_t handler);函数来说，signum 显然是信号的编号，handler 是中断函数的指针。
同样，typedef void (*sighandler_t)(int);中断函数的原型中，有一个参数是 int 类型，显然也是信号产生的类型，方便使用一个函数来处理多个信号。我们先来看看简单一个信号注册的代码示例吧。

#include<signal.h>
#include<stdio.h>
#include <unistd.h>

//typedef void (*sighandler_t)(int);
void handler(int signum)
{
    if(signum == SIGIO)
        printf("SIGIO   signal: %d\n", signum);
    else if(signum == SIGUSR1)
        printf("SIGUSR1   signal: %d\n", signum);
    else
        printf("error\n");
}

int main(void)
{
    //sighandler_t signal(int signum, sighandler_t handler);
    signal(SIGIO, handler);
    signal(SIGUSR1, handler);
    printf("%d  %d\n", SIGIO, SIGUSR1);
    for(;;)
    {
        sleep(10000);
    }
    return 0;
}

简单的总结一下，我们通过 signal 函数注册一个信号处理函数，分别注册了两个信号（SIGIO 和 SIGUSER1）；随后主程序就一直“长眠”了。
通过 kill 命令发送信号之前，我们需要先查看到接收者，通过 ps 命令查看了之前所写的程序的 PID，通过 kill 函数来发送。
对于已注册的信号，使用 kill 发送都可以正常接收到，但是如果发送了未注册的信号，则会使得应用程序终止进程。

那么，已经可以设置信号处理函数了，信号的处理还有两种状态，分别是默认处理和忽略，这两种设置很简单，只需要将 handler 设置为 SIG_IGN（忽略信号）或 SIG_DFL（默认动作）即可。
在此还有两个问题需要说明一下：

1. 当执行一个程序时，所有信号的状态都是系统默认或者忽略状态的。除非是 调用exec进程忽略了某些信号。exec 函数将原先设置为要捕捉的信号都更改为默认动作，其他信号的状态则不会改变 。

2. 当一个进程调动了 fork 函数，那么子进程会继承父进程的信号处理方式。
   入门版的信号注册还是比较简单的，只需要一句注册和一个处理函数即可，那么，接下来看看，如何发送信号吧。

   • signal 函数用于注册信号处理函数，以定义信号到来时要执行的操作。它是Unix传统的信号处理方式，但在一些情况下会有一些限制。
   • 原型：void (*signal(int signum, void (*handler)(int))) (int);
   • signum 是信号的整数标识，handler 是信号处理函数的指针。
   • 信号处理函数的原型通常是 void handler(int signum)。
   • signal 返回一个指向先前信号处理函数的指针。
   • 这种方式的信号处理在一些情况下可能不够灵活，因此更现代的 sigaction 函数通常更常用。

2. kill 函数

kill 函数：

• kill 函数用于向指定进程或进程组发送信号。
• 原型：int kill(pid_t pid, int sig);
• pid 是接收信号的进程的进程标识符（PID）或进程组标识符。
• sig 是要发送的信号的整数标识。
• 通常，kill 函数用于向进程发送终止信号，但也可以用于其他目的，如自定义事件通知。

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

	int kill(pid_t pid, int sig);

正如我之前所说的，信号的处理需要有接受者，显然发送者必须要知道发给谁，根据 kill 函数的远行可以看到，pid 就是接受者的 pid，sig 则是发送的信号的类型。

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

int main(int argc, char** argv)
{
    if (3 != argc)
    {
        printf("[Arguments ERROR!]\n");
        printf("\tUsage:\n");
        printf("\t\t%s <Target_PID> <Signal_Number>\n", argv[0]);
        return -1;
    }
    int pid = atoi(argv[1]);
    int sig = atoi(argv[2]);
    //int kill(pid_t pid, int sig);
    if (pid > 0 && sig > 0)
    {
        kill(pid, sig);
    }
    else
    {
        printf("Target_PID or Signal_Number MUST bigger than 0!\n");
    }
    
    return 0;
}

总结一下：
根据以上的结果可看到，基本可以实现了信号的发送，虽然不能直接发送信号名称，但是通过信号的编号，可以正常的给程序发送信号了，也是初步实现了信号的发送流程。

关于 kill 函数，还有一点需要额外说明，上面的程序限定了 pid 必须为大于0的正整数，其实 kill 函数传入的 pid 可以是小于等于0的整数。
pid > 0：将发送个该 pid 的进程
pid == 0：将会把信号发送给与发送进程属于同一进程组的所有进程，并且发送进程具有权限想这些进程发送信号。
pid < 0：将信号发送给进程组ID 为 pid 的绝对值得，并且发送进程具有权限向其发送信号的所有进程
pid == -1：将该信号发送给发送进程的有权限向他发送信号的所有进程。（不包括系统进程集中的进程）

关于信号，还有更多的话题，比如，信号是否都能够准确的送达到目标进程呢？答案其实是不一定，那么这就有了可靠信号和不可靠信号

3. 可靠信号和不可靠信号

不可靠信号：信号可能会丢失，一旦信号丢失了，进程并不能知道信号丢失
可靠信号：也是阻塞信号，当发送了一个阻塞信号，并且该信号的动作时系统默认动作或捕捉该信号，如果信号从发出以后会一直保持未决的状态，直到该进程对此信号解除了阻塞，或将对此信号的动作更改为忽略。
对于信号来说，信号编号小于等于31的信号都是不可靠信号，之后的信号为可卡信号，系统会根据有信号队列，将信号在递达之前进行阻塞。

信号的阻塞和未决是通过信号的状态字来管理的，该状态字是按位来管理信号的状态。每个信号都有独立的阻塞字，规定了当前要阻塞地达到该进程的信号集。

信号阻塞状态字（block），1代表阻塞、0代表不阻塞；信号未决状态字（pending）的1代表未决，0代表信号可以抵达了；它们都是每一个bit代表一个信号

• 阻塞和未决是如何工作的？
  比如向进程发送SIGINT信号，内核首先会判断该进程的信号阻塞状态字是否阻塞状态，如果该信号被设置为阻塞的状态，也就是阻塞状态字对应位为1，那么信号未决状态字（pending）相应位会被内核设置为1；如果该信号阻塞解除了，也就是阻塞状态字设置为了0，那么信号未决状态字（pending）相应位会被内核设置为0，表示信号此时可以抵达了，也就是可以接收该信号了。
  阻塞状态字用户可以读写，未决状态字用户只能读，是由内核来设置表示信号递达状态的。
  PS:这里额外说明以下，只有支持了 POSIX.1实时扩展的系统才支持排队的功能（也就阻塞状态下多次同一信号发送给某一进程可以得到多次，而不是一次）。

• 关于进程关于信号的阻塞状态字的设置
  可以通过int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);函数来获取或者设置。

该函数管理信号，是通过信号集的数据结构来进行管理的，信号集可以通过以下的函数进行管理。
信号集操作函数（状态字表示）

#include <signal.h>
       int sigemptyset(sigset_t *set);  //初始化 set 中传入的信号集，清空其中所有信号
       int sigfillset(sigset_t *set);  //把信号集填1，让 set 包含所有的信号
       int sigaddset(sigset_t *set, int signum);//把信号集对应位置为1
       int sigdelset(sigset_t *set, int signum);//吧信号集对应位置为0
       int sigismember(const sigset_t *set, int signum);//判断signal是否在信号集

对于信号集分配好内存空间，需要使用初始化函数来初始化。初始化完成后，可以在该集合中添加、删除特定的信号。
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
其中 how 变量决定了是如何操作该状态字。
SIG_BLOCK：set包含了我们希望添加到当前信号阻塞字的信号，相当于mask=mask|set
SIG_UNBLOCK：set包含了我们希望从当前信号阻塞字中解除阻塞的信号，相当于mask=mask&~set
SIG_SETMASK：设置当前信号阻塞字为set所指的值，相当于mask=set

pending是由内核来根据block设置的，只可以读取其中的数据，来段判断信号是否会递达。通过设置block可以将希望阻塞的信号进行阻塞，对应的pending会由内核来设置

设置信号阻塞、未达的步骤：

1. 分配内存空间sigset sigset bset;
2. 置空sigemptyset(&bset);
3. 添加信号sigaddset(&bset, SIGINT);
4. 添加其他需要管理的信号…
5. 设置信号集中的信号处理方案（此处为解除阻塞）sigprocmask(SIG_UNBLOCK, &bset, NULL);

简化版设置阻塞状态字

#include <signal.h>
int sigpending(sigset_t *set);

这个函数使用很简单，对于调用他的进程来说，其中信号集中的信号是阻塞不能递送的，那么，也就一定会是当前未决的。

原子操作的信号阻塞字的恢复并进入休眠状态

#include <signal.h>
int sigsuspend(const sigset_t *mask);

• 为何会出现原子性的解除阻塞的函数呢？
  因为，当信号被阻塞的时候，产生了信号，那么该信号的递送就要推迟到这个信号被解除了阻塞为止。如果此时，应用程序正好处在，解除 SIGINT 的阻塞和 pause 之间，那么此时，会产生问题，可能永远 pause 不能够等到SIGINT 信号来打断他，造成程序永久阻塞在 pause 处。
  为了解决这个问题，，需要在一个原子性的操作来恢复信号的屏蔽字，然后才能让进程进入休眠状态，以保证不会出现上述的问题。

4. sigaction 函数

sigaction 函数：

• sigaction 函数用于注册信号处理函数，并提供更多的控制选项，因此比 signal 更灵活和可移植。
• 原型：int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
• signum 是信号的整数标识，act 是一个指向 struct sigaction 结构的指针，用于指定新的信号处理方式。
• oldact 是一个可选参数，如果提供，将存储原来的信号处理方式。
• struct sigaction 结构允许您指定各种选项，包括信号处理函数、信号处理标志和信号掩码等。

我们已经成功完成了信号的收发，那么为什么会有高级版出现呢？其实之前的信号存在一个问题就是，虽然发送和接收到了信号，可是总感觉少些什么，既然都已经把信号发送过去了，为何不能再携带一些数据呢？
正是如此，我们需要另外的函数来通过信号传递的过程中，携带一些数据。咱么先来看看发送的函数吧。

#include <signal.h>

	int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

struct sigaction {
   void       (*sa_handler)(int); 
   //信号处理程序，不接受额外数据，SIG_IGN 为忽略，SIG_DFL 为默认动作
   void       (*sa_sigaction)(int, siginfo_t *, void *); 
   //信号处理程序，能够接受额外数据和sigqueue配合使用
   sigset_t   sa_mask;
   //阻塞关键字的信号集，可以再调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。
   int        sa_flags;
   //影响信号的行为SA_SIGINFO表示能够接受数据
 };
//回调函数句柄sa_handler、sa_sigaction只能任选其一

这个函数的原版帮助信息，可以通过man sigaction来查看。

sigaction 是一个系统调用，根据这个函数原型，我们不难看出，在函数原型中，第一个参数signum应该就是注册的信号的编号；第二个参数act如果不为空说明需要对该信号有新的配置；第三个参数oldact如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。

在这里额外说一下struct sigaction结构体中的 sa_mask 成员，设置在其的信号集中的信号，会在捕捉函数调用前设置为阻塞，并在捕捉函数返回时恢复默认原有设置。这样的目的是，在调用信号处理函数时，就可以阻塞默写信号了。在信号处理函数被调用时，操作系统会建立新的信号阻塞字，包括正在被递送的信号。因此，可以保证在处理一个给定信号时，如果这个种信号再次发生，那么他会被阻塞到对之前一个信号的处理结束为止。

sigaction 的时效性：当对某一个信号设置了指定的动作的时候，那么，直到再次显式调用 sigaction并改变动作之前都会一直有效。

关于结构体中的 flag 属性的详细配置，在此不做详细的说明了，只说明其中一点。如果设置为 SA_SIGINFO 属性时，说明了信号处理程序带有附加信息，也就是会调用 sa_sigaction 这个函数指针所指向的信号处理函数。否则，系统会默认使用 sa_handler 所指向的信号处理函数。在此，还要特别说明一下，sa_sigaction 和 sa_handler 使用的是同一块内存空间，相当于 union，所以只能设置其中的一个，不能两个都同时设置。

关于void (*sa_sigaction)(int, siginfo_t *, void );处理函数来说还需要有一些说明。void 是接收到信号所携带的额外数据；而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息。

 siginfo_t {
               int      si_signo;    /* Signal number */
               int      si_errno;    /* An errno value */
               int      si_code;     /* Signal code */
               int      si_trapno;   /* Trap number that caused
                                        hardware-generated signal
                                        (unused on most architectures) */
               pid_t    si_pid;      /* Sending process ID */
               uid_t    si_uid;      /* Real user ID of sending process */
               int      si_status;   /* Exit value or signal */
               clock_t  si_utime;    /* User time consumed */
               clock_t  si_stime;    /* System time consumed */
               sigval_t si_value;    /* Signal value */
               int      si_int;      /* POSIX.1b signal */
               void    *si_ptr;      /* POSIX.1b signal */
               int      si_overrun;  /* Timer overrun count; POSIX.1b timers */
               int      si_timerid;  /* Timer ID; POSIX.1b timers */
               void    *si_addr;     /* Memory location which caused fault */
               int      si_band;     /* Band event */
               int      si_fd;       /* File descriptor */
}

其中的成员很多，si_signo 和 si_code 是必须实现的两个成员。可以通过这个结构体获取到信号的相关信息。
关于发送过来的数据是存在两个地方的，sigval_t si_value这个成员中有保存了发送过来的信息；同时，在si_int或者si_ptr成员中也保存了对应的数据。

那么，kill 函数发送的信号是无法携带数据的，我们现在还无法验证发送收的部分，那么，我们先来看看发送信号的高级用法后，我们再来看看如何通过信号来携带数据吧。

5. sigqueue 函数

sigqueue 函数：

• sigqueue 函数用于向指定进程发送信号，类似于 kill，但允许传递附加数据。
• 原型：int sigqueue(pid_t pid, int sig, const union sigval value);
• pid 是接收信号的进程的进程标识符。
• sig 是要发送的信号的整数标识。
• value 是一个 union sigval 结构，允许传递一个整数值和一个指针，以传递附加数据给接收进程。
• 这对于需要传递更多信息的特殊用例非常有用。

这些函数和系统调用在信号处理和进程间通信中发挥重要作用，它们可以用于实现异步事件处理、错误处理、进程间通信和自定义事件通知等功能。在使用它们时，需要了解不同信号的含义和用途，以确保正确处理和发送信号。

#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {
   int   sival_int;
   void *sival_ptr;
 };

使用这个函数之前，必须要有几个操作需要完成

1. 使用 sigaction 函数安装信号处理程序时，制定了 SA_SIGINFO 的标志。
   sigaction 结构体中的 sa_sigaction 成员提供了信号捕捉函数。如果实现的时 sa_handler 成员，那么将无法获取额外携带的数据。
   sigqueue 函数只能把信号发送给单个进程，可以使用 value 参数向信号处理程序传递整数值或者指针值。

2. sigqueue 函数不但可以发送额外的数据，还可以让信号进行排队（操作系统必须实现了 POSIX.1的实时扩展），对于设置了阻塞的信号，使用 sigqueue 发送多个同一信号，在解除阻塞时，接受者会接收到发送的信号队列中的信号，而不是直接收到一次。

但是，信号不能无限的排队，信号排队的最大值受到SIGQUEUE_MAX的限制，达到最大限制后，sigqueue 会失败，errno 会被设置为 EAGAIN。

接收端

//receive.c
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

//void (*sa_sigaction)(int, siginfo_t *, void *);
void handler(int signum, siginfo_t * info, void * context)
{
    if (signum == SIGIO)
        printf("SIGIO   signal: %d\n", signum);
    else if (signum == SIGUSR1)
        printf("SIGUSR1   signal: %d\n", signum);
    else
        printf("error\n");
    
    if (context)
    {
        printf("content: %d\n", info->si_int);
        printf("content: %d\n", info->si_value.sival_int);
    }
}

int main(void)
{
    //int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
    struct sigaction act;
    
    /*
     struct sigaction {
     void     (*sa_handler)(int);
     void     (*sa_sigaction)(int, siginfo_t *, void *);
     sigset_t   sa_mask;
     int        sa_flags;
     };
     */
    act.sa_sigaction = handler;
    act.sa_flags = SA_SIGINFO;
    
    sigaction(SIGIO, &act, NULL);
    sigaction(SIGUSR1, &act, NULL);
    for (;;)
    {
        sleep(10000);
    }
    return 0;
}

发送端

//sender.c
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char** argv)
{
    if (4 != argc)
    {
        printf("[Arguments ERROR!]\n");
        printf("\tUsage:\n");
        printf("\t\t%s <Target_PID> <Signal_Number> <content>\n", argv[0]);
        return -1;
    }
    int pid = atoi(argv[1]);
    int sig = atoi(argv[2]);

    if (pid > 0 && sig > 0)
    {
        //int sigqueue(pid_t pid, int sig, const union sigval value);
        union sigval val;
        val.sival_int = atoi(argv[3]);
        printf("send: %d\n", atoi(argv[3]));
        sigqueue(pid, sig, val);
    }
    else
    {
        printf("Target_PID or Signal_Number MUST bigger than 0!\n");
    }
    
    return 0;
}

sigaction 函数和sigqueue 函数

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

void handler(int signum, siginfo_t *info, void *context)
{
    printf("get signum %d\n", signum);
    
    if (context != NULL) {
        printf("from:%d\n", info->si_pid); // 打印发送信号的进程的PID
        printf("get data=%d\n", *(int *)(info->si_value.sival_ptr)); // 打印通过信号传递的数据（整数）
    }
}

int main()
{
    struct sigaction act; // 创建一个sigaction结构体

    printf("pid = %d\n", getpid()); // 打印当前进程的PID

    act.sa_sigaction = handler; // 设置信号处理函数为handler
    act.sa_flags = SA_SIGINFO; // 设置标志以便能够获取附加信息

    sigaction(SIGUSR1, &act, NULL); // 设置SIGUSR1信号的处理函数为handler，允许获取附加信息

    while (1); // 无限循环，等待信号的到来

    return 0;
}

//sigqueue.c
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
	int signum; // 用于存储从命令行参数中获取的信号编号
	int pid;    // 用于存储从命令行参数中获取的进程ID

	signum = atoi(argv[1]); // 从命令行参数中获取信号编号并转换为整数
	pid = atoi(argv[2]);    // 从命令行参数中获取进程ID并转换为整数

	int a = 10; // 创建一个整数变量a，用于传递给信号
	union sigval value; // 创建一个联合体sigval来存储传递给信号的值

	value.sival_ptr = &a; // 将整数变量a的地址存储在sigval联合体中，准备发送给信号
	// 以下几行代码是注释掉的，它们演示了不同的sigval数据类型的用法
	// value.sival_int = 100; // 将整数值100存储在sigval联合体中，准备发送给信号
	// strcpy(value.sival_ptr, "vale"); // 尝试将字符串 "vale" 存储在sigval联合体中，但有问题
	// value.sival_ptr = &a; // 将整数变量a的地址存储在sigval联合体中，准备发送给信号

	// int sigqueue(pid_t pid, int sig, const union sigval value);
	sigqueue(pid, signum, value); // 向指定进程发送指定信号和附加数据

	printf("%d,done\n", getpid()); // 打印当前进程的PID

	return 0;
}

六、信号量semget、semop、semctl

信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

1、特点

• 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。

• 信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。

• 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

• 支持信号量组。

2、原型
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

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

// 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);
// 控制信号量的相关信息
int semctl(int semid, int sem_num, int cmd, ...);

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) */
};

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。

在semop函数中，sembuf结构的定义如下：

struct sembuf
{
    short sem_num; // 信号量组中对应的序号，0～sem_nums-1
    short sem_op;  // 信号量值在一次操作中的改变量
    short sem_flg; // IPC_NOWAIT, SEM_UNDO
}

其中 sem_op 是一次操作中的信号量的改变量：

• 若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。

• 若sem_op < 0，请求 sem_op 的绝对值的资源。

  • 如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
  • 当相应的资源数不能满足请求时，这个操作与sem_flg有关。
  • sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
  • sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
  • 当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
  • 此信号量被删除，函数smeop出错返回EIDRM；
  • 进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR

• 若sem_op == 0，进程阻塞直到信号量的相应值为0：

  • 当信号量已经为0，函数立即返回。
  • 如果信号量的值不为0，则依据sem_flg决定函数动作：
  • sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
  • sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
  • 信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
  • 此信号量被删除，函数smeop出错返回EIDRM；
  • 进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

在semctl函数中的命令有多种，这里就说两个常用的：

• SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
• IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

//semaphore.c
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

// 定义一个联合体，用于在semctl中操作信号量
union semun 
{
	int              val;    // 用于SETVAL操作，设置信号量的值
	struct semid_ds *buf;    // 用于IPC_STAT和IPC_SET操作，获取和设置信号量集合的属性
	unsigned short  *array;  // 用于GETALL和SETALL操作，获取和设置多个信号量的值
	struct seminfo  *__buf;  // 用于IPC_INFO操作（特定于Linux）
};

// 初始化信号量
int init_sem(int sem_id, int value)
{
	if (semctl(sem_id, 0, SETVAL) == -1)
	{
		perror("Init Semaphore Error\n");
		return -1;
	}
	return 0;
}

// P操作:
//    若信号量值为1,获取资源并将信号量值-1 
//    若信号量值为0,进程挂起等待
int sem_p(int sem_id)
{
	struct sembuf sbuf;
	
	sbuf.sem_num = 0; /*序号*/
	sbuf.sem_op = -1; /*P操作*/
	sbuf.sem_flg = SEM_UNDO;

	if (semop(sem_id, &sbuf, 1) == -1)
	{
		perror("P operation Error\n");
		return -1;
	}
	return 0;
}

// V操作:
//    释放资源并将信号量值+1
//    如果有进程正在挂起等待,则唤醒它们
int sem_v(int sem_id)
{
	struct sembuf sbuf;
	
	sbuf.sem_num = 0; /*序号*/
	sbuf.sem_op = 1;  /*V操作*/
	sbuf.sem_flg = SEM_UNDO;

	if(semop(sem_id, &sbuf, 1) == -1)
	{
		perror("V operation Error\n");
		return -1;
	}
	return 0;
}

// 删除信号量集
int del_sem(int sem_id)
{
	union semun tmp;
	
	if (semctl(sem_id, 0, IPC_RMID, tmp) == -1)
	{
		perror("Delete Semaphore Error\n");
		return -1;
	}
	return 0;
}

int main()
{
	int sem_id;  // 信号量集ID
	key_t key;  
	pid_t pid;

	// 获取key值
	if ((key = ftok(".", 'z')) < 0)
	{
		perror("ftok error\n");
		exit(1);
	}

	// 创建信号量集,其中只有一个信号量
	if ((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
	{
		perror("semget error\n");
		exit(1);
	}

	// 初始化:初值设为0资源被占用
	init_sem(sem_id, 0);

	if ((pid = fork()) == -1)
		perror("Fork Error\n");
	else if (pid == 0) /*子进程*/ 
	{
		sleep(2);
		printf("Process child: pid=%d\n", getpid());
		sem_v(sem_id);  /*释放资源*/
	}
	else  /*父进程*/
	{
		sem_p(sem_id);   /*等待资源*/
		printf("Process father: pid=%d\n", getpid());
		sem_v(sem_id);   /*释放资源*/
		del_sem(sem_id); /*删除信号量集*/
	}
	return 0;
}

上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。

semget、semop、semctl函数API

这些函数是在Unix/Linux系统中用于创建、操作和管理信号量的函数。信号量是一种用于进程间通信和同步的IPC（Inter-Process Communication）机制，用于协调多个进程对共享资源的访问。以下是对这些函数的详细介绍：

1. semget 函数：

   • semget 函数用于创建一个新的信号量集合或获取现有信号量集合的标识符。
   • 原型：int semget(key_t key, int nsems, int semflg);
   • key 是用于标识信号量集合的键，通常使用 ftok 函数生成。
   • nsems 是信号量集合中信号量的数量。
   • semflg 是标志，用于指定信号量集合的创建方式和访问权限。
   • semget 返回一个标识符，该标识符用于在后续操作中引用信号量集合。

2. semop 函数：

   • semop 函数用于对信号量集合中的一个或多个信号量执行操作，如增加或减少信号量的值。
   • 原型：int semop(int semid, struct sembuf *sops, unsigned nsops);
   • semid 是信号量集合的标识符。
   • sops 是一个指向 struct sembuf 结构数组的指针，用于指定要执行的操作。每个 struct sembuf 结构描述一个操作，包括信号量编号、操作类型（增加或减少）、和操作标志。
   • nsops 是指定的操作数量。
   • semop 函数在执行操作时可能会阻塞进程，直到操作成功或超时。

3. semctl 函数：

   • semctl 函数用于控制和管理信号量集合，包括获取或设置信号量的值、删除信号量等操作。
   • 原型：int semctl(int semid, int semnum, int cmd, ...);
   • semid 是信号量集合的标识符。
   • semnum 是信号量在集合中的编号。
   • cmd 是要执行的命令，可以是不同的命令，如获取信号量的值、设置信号量的值、删除信号量等，通过union semun来传递具体参数。
   • semctl 返回操作的结果或值，具体返回值根据命令的不同而不同。

这些函数允许进程创建和操作信号量，以实现同步和互斥，确保多个进程之间对共享资源的安全访问。在使用这些函数时，需要小心处理同步和互斥问题，以避免竞态条件和数据不一致性。通常，信号量用于解决多进程之间的资源共享问题，例如生产者-消费者问题、读者-写者问题等。

//sem.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

// 定义一个联合体，用于在semctl中操作信号量
union semun 
{
	int              val;    // 用于SETVAL操作，设置信号量的值
	struct semid_ds *buf;    // 用于IPC_STAT和IPC_SET操作，获取和设置信号量集合的属性
	unsigned short  *array;  // 用于GETALL和SETALL操作，获取和设置多个信号量的值
	struct seminfo  *__buf;  // 用于IPC_INFO操作（特定于Linux）
};

// P操作，获取锁
void pGetKey(int id)
{
	struct sembuf set;

	set.sem_num = 0; // 操作第一个信号量
	set.sem_op = -1; // 执行P操作，减1表示获取锁
	set.sem_flg = SEM_UNDO; // 使用SEM_UNDO标志，确保在进程异常退出时释放锁

	semop(id, &set, 1); // 执行P操作
	printf("getkey\n");
}

// V操作，释放锁
void vPutBackKey(int id)
{
	struct sembuf set;

	set.sem_num = 0; // 操作第一个信号量
	set.sem_op = 1;  // 执行V操作，加1表示释放锁
	set.sem_flg = SEM_UNDO; // 使用SEM_UNDO标志，确保在进程异常退出时释放锁

	semop(id, &set, 1); // 执行V操作
	printf("put back the key\n");
}

int main(int argc, char const *argv[])
{
	key_t key;
	int semid;

	key = ftok(".", 2); // 通过ftok创建一个唯一的键值，用于标识信号量集合

	semid = semget(key, 1, IPC_CREAT|0666); // 获取或创建一个信号量集合，包含一个信号量

	union semun initsem;
	initsem.val = 0; // 初始化信号量的值为0

	// 初始化信号量，将其值设置为0
	semctl(semid, 0, SETVAL, initsem);

	int pid = fork(); // 创建一个子进程
	if (pid > 0) 
	{
		// 父进程
		pGetKey(semid); // 获取锁
		printf("this is parent process\n");
		vPutBackKey(semid); // 释放锁
		// 释放信号量集合
		semctl(semid, 0, IPC_RMID);
	}
	else if (pid == 0)
	{
		// 子进程
		printf("this is child process\n");
		vPutBackKey(semid); // 释放锁
	}
	else
	{
		printf("fork error\n"); // 创建子进程失败
	}

	return 0;
}

共享内存+信号量+消息队列

下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。

• 共享内存用来传递数据；
• 信号量用来同步；
• 消息队列用来 在客户端修改了共享内存后 通知服务器读取。

server.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy

// 消息队列结构
struct msg_form {
    long mtype;
    char mtext;
};

// 联合体，用于semctl初始化
union semun
{
    int              val; /*for SETVAL*/
    struct semid_ds *buf;
    unsigned short  *array;
};

// 初始化信号量
int init_sem(int sem_id, int value)
{
    union semun tmp;
    tmp.val = value;
    if(semctl(sem_id, 0, SETVAL, tmp) == -1)
    {
        perror("Init Semaphore Error");
        return -1;
    }
    return 0;
}

// P操作:
//  若信号量值为1，获取资源并将信号量值-1
//  若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序号*/
    sbuf.sem_op = -1; /*P操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V操作：
//  释放资源并将信号量值+1
//  如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序号*/
    sbuf.sem_op = 1;  /*V操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("V operation Error");
        return -1;
    }
    return 0;
}

// 删除信号量集
int del_sem(int sem_id)
{
    union semun tmp;
    if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
    {
        perror("Delete Semaphore Error");
        return -1;
    }
    return 0;
}

// 创建一个信号量集
int creat_sem(key_t key)
{
    int sem_id;
    if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
    {
        perror("semget error");
        exit(-1);
    }
    init_sem(sem_id, 1);  /*初值设为1资源未占用*/
    return sem_id;
}


int main()
{
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    char data[] = "this is server";
    struct shmid_ds buf1;  /*用于删除共享内存*/
    struct msqid_ds buf2;  /*用于删除消息队列*/
    struct msg_form msg;  /*消息队列用于通知对方更新了共享内存*/

    // 获取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 创建共享内存
    if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
    {
        perror("Create Shared Memory Error");
        exit(1);
    }

    // 连接共享内存
    shm = (char*)shmat(shmid, 0, 0);
    if((int)shm == -1)
    {
        perror("Attach Shared Memory Error");
        exit(1);
    }


    // 创建消息队列
    if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 创建信号量
    semid = creat_sem(key);

    // 读数据
    while(1)
    {
        msgrcv(msqid, &msg, 1, 888, 0); /*读取类型为888的消息*/
        if(msg.mtext == 'q')  /*quit - 跳出循环*/
            break;
        if(msg.mtext == 'r')  /*read - 读共享内存*/
        {
            sem_p(semid);
            printf("%s\n",shm);
            sem_v(semid);
        }
    }

    // 断开连接
    shmdt(shm);

    /*删除共享内存、消息队列、信号量*/
    shmctl(shmid, IPC_RMID, &buf1);
    msgctl(msqid, IPC_RMID, &buf2);
    del_sem(semid);
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy

// 消息队列结构
struct msg_form {
    long mtype;
    char mtext;
};

// 联合体，用于semctl初始化
union semun
{
    int              val; /*for SETVAL*/
    struct semid_ds *buf;
    unsigned short  *array;
};

// P操作:
//  若信号量值为1，获取资源并将信号量值-1
//  若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序号*/
    sbuf.sem_op = -1; /*P操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V操作：
//  释放资源并将信号量值+1
//  如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序号*/
    sbuf.sem_op = 1;  /*V操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("V operation Error");
        return -1;
    }
    return 0;
}


int main()
{
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    struct msg_form msg;
    int flag = 1; /*while循环条件*/

    // 获取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 获取共享内存
    if((shmid = shmget(key, 1024, 0)) == -1)
    {
        perror("shmget error");
        exit(1);
    }

    // 连接共享内存
    shm = (char*)shmat(shmid, 0, 0);
    if((int)shm == -1)
    {
        perror("Attach Shared Memory Error");
        exit(1);
    }

    // 创建消息队列
    if ((msqid = msgget(key, 0)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 获取信号量
    if((semid = semget(key, 0, 0)) == -1)
    {
        perror("semget error");
        exit(1);
    }

    // 写数据
    printf("***************************************\n");
    printf("*                 IPC                 *\n");
    printf("*    Input r to send data to server.  *\n");
    printf("*    Input q to quit.                 *\n");
    printf("***************************************\n");

    while(flag)
    {
        char c;
        printf("Please input command: ");
        scanf("%c", &c);
        switch(c)
        {
            case 'r':
                printf("Data to send: ");
                sem_p(semid);  /*访问资源*/
                scanf("%s", shm);
                sem_v(semid);  /*释放资源*/
                /*清空标准输入缓冲区*/
                while((c=getchar())!='\n' && c!=EOF);
                msg.mtype = 888;
                msg.mtext = 'r';  /*发送消息通知服务器读数据*/
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                break;
            case 'q':
                msg.mtype = 888;
                msg.mtext = 'q';
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                flag = 0;
                break;
            default:
                printf("Wrong input!\n");
                /*清空标准输入缓冲区*/
                while((c=getchar())!='\n' && c!=EOF);
        }
    }

    // 断开连接
    shmdt(shm);

    return 0;
}

注意：当scanf()输入字符或字符串时，缓冲区中遗留下了\n，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持fflush(stdin)（它只是标准C的扩展），所以我们使用了替代方案：

while ((c = getchar()) != '\n' && c != EOF);