本文主要是介绍Linux 3.进程间通信（shmget shmat shmdt shmctl 共享内存、signal signaction sigqueue 信号、semget semctl semop 信号量），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Linux 3.进程间通信（IPC）

• 共享内存
• • 共享内存的接口指令
  • shmget 创建获取获取共享内存
  • shmat 映射：连接共享内存到当前进程的地址空间
  • shmdt 断开与共享内存的连接
  • shmctl 控制或者删除共享内存的相关信息
  • 共享内存 示例
  • • shmw.out
    • shmr.out
• 信号（signal）
• • 信号的处理
  • 入门版（signal）
  • • signal 功能
    • signal 头文件及函数原型
    • signal 参数
    • 忽略信号（SIG_IGN）：
    • 捕获信号
    • 恢复默认动作（SIG_DFL）
    • 写个程序来发指令
  • 高级版（sigaction sigqueue）
  • • sigaction（信号接受函数）
    • • sigaction 功能
      • sigaction 头文件及原型
      • sigaction 参数
    • sigqueue （信号发送函数）
    • • sigaction 功能
      • sigaction 头文件及原型
      • sigaction 参数
    • sigaction sigqueue 使用示例
    • • sigaction
      • sigqueue
• 信号量（semget semop semctl）
• • 信号量特点
  • semget（创建或者获取一个信号量组）
  • semctl（控制信号量的相关信息）
  • semop（对信号量组进行操作，改变信号量的值）
  • 信号量 示例

共享内存

共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。

共享内存的接口指令

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

ipcs -m

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

ipcrm -m [shmid]

shmget 创建获取获取共享内存

注意：size： 大于0的整数：新建的共享内存大小，以字节为单位 3,072k（3kb）

shmat 映射：连接共享内存到当前进程的地址空间

shmdt 断开与共享内存的连接

shmctl 控制或者删除共享内存的相关信息

共享内存 示例

shmw.out

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

int main()
{
	key_t key=ftok(".",1);
	
	int shmId=shmget(key,1024*3,IPC_CREAT|0666);
	if(shmId==-1)
	{
		printf("shmget fail!\n");
		exit(-1);
	}
	
	char* shmaddr=shmat(shmId,NULL,0);
	if(*shmaddr==-1)
	{
		printf("shmat fail!\n");
		exit(-1);
	}
	
	strcpy(shmaddr,"Yinyuer is a pretty girl!");
	sleep(3); //避免写程序运行太快，读程序读取不到
	
	int dt=shmdt(shmaddr);
	if(dt==-1)
	{
		printf("shmdt fail!\n");
		exit(-1);
	}
	
	shmctl(shmId,IPC_RMID,0);
	printf("EXIT!\n");
	
	return 0;
}

shmr.out

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

int main()
{
	key_t key=ftok(".",1);
	
	int shmId=shmget(key,1024*3,0);
	if(shmId==-1)
	{
		printf("shmget fail!\n");
		exit(-1);
	}
	
	char* shmaddr=shmat(shmId,NULL,0);
	if(*shmaddr==-1)
	{
		printf("shmat fail!\n");
		exit(-1);
	}
	
	printf("shm from shmw:\n%s\n",shmaddr);
	
	int dt=shmdt(shmaddr);
	if(dt==-1)
	{
		printf("shmdt fail!\n");
		exit(-1);
	}
	
	shmctl(shmId,IPC_RMID,0);
	printf("EXIT!\n");
	
	return 0;
}

运行结果：

信号（signal）

对于 Linux，实际信号是软中断，许多重要的程序也需要处理信号，信号能为 Linux 提供一种处理异常的方法，比如 Ctrl + C 中断 程序，会通过信号机制停止程序。

信号都有名字和编号，信号名都定义为正整数，具体信号名称可以通过 kill -l 查看信号名字以及编号。信号是从 1 开始编号的，不存在 0， kill对信号0有特殊意义。

kill -l

信号的处理

3种：忽略、捕捉、默认动作。

忽略：不能忽略的两个信号：SIGKILL、 SIGSTOP。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景

捕捉：由内核来调用用户自定义的函数，来实现某种信号的处理。

默认动作：对于每个信号，系统都对应由默认的处理动作。具体的可以 man 7 signal 查看。

入门版（signal）

signal 功能

设置某一信号的对应动作。

signal 头文件及函数原型

#include <signal.h>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

signal 参数

signum：指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。

handler：描述了与信号关联的动作，它可以取以下三种值：

（1）一个无返回值的函数地址
此函数必须在signal()被调用前申明，handler中为这个函数的名字。当接收到一个类型为signum的信号时，就执行handler 所指定的函数。这个函数应有如下形式的定义：
void func(int sig);

（2）SIG_IGN
这个符号表示忽略该信号，执行了相应的signal()调用后，进程会忽略类型为sig的信号。

（3）SIG_DFL
这个符号表示恢复系统对信号的默认处理。

忽略信号（SIG_IGN）：

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

void handler(int signum)
{
	printf("signum=%d\n",signum);
	switch(signum)
	{
		case 2:
			printf("SIGINT\n");
			break;
		case 9:
			printf("SIGKILL\n");
			break;
		case 10:
			printf("SIGUSR1\n");
			break;
		default:
			break;
	}
}

int main()
{
	signal(SIGINT,SIG_IGN);
	signal(SIGKILL,SIG_IGN);
	signal(SIGUSR1,handler);
	
	while(1);
	
	return 0;
}

运行结果：

对 Ctrl+C/SIGINT 起忽略作用，但对 SIGKILL 不可忽略。

捕获信号

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

void handler(int signum)
{
	printf("signum=%d\n",signum);
	switch(signum)
	{
		case 2:
			printf("SIGINT\n");
			break;
		case 9:
			printf("SIGKILL\n");
			break;
		case 10:
			printf("SIGUSR1\n");
			break;
		default:
			break;
	}
}

int main()
{
	signal(SIGINT,handler);
	signal(SIGKILL,handler);
	signal(SIGUSR1,handler);
	
	while(1);
	
	return 0;
}

运行结果：

恢复默认动作（SIG_DFL）

这个符号表示恢复系统对信号的默认处理。

写个程序来发指令

上面的都是直接通过键盘发指令的，我们也可以写个程序来发指令。

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

int main(int argc,char** argv)
{
	int signum;
	int pid;
	
	signum=atoi(argv[1]);
	pid=atoi(argv[2]);

	printf("signum=%d pid=%d\n",signum,pid);
	
	kill(pid,signum);
	
//	char cmd[128]={0};
//	sprintf(cmd,"kill %d %d",signum,pid);
//	system(cmd);
	
	return 0;
}

通过 ps -aux 指令来获取进程的 pid 号，对 9-1-signal.out 进程操作

ps -aux|grep ./9-1-signal.out

高级版（sigaction sigqueue）

为什么会有高级版，我们的入门版虽然可以发出和接收到了信号，但我们想发出信号的同时携带点数据，这时候需要用到高级版 sigaction。

sigaction（信号接受函数）

sigaction 功能

sigaction()会依参数signum指定的信号编号来设置该信号的处理函数。参数signum可以指定SIGKILL和SIGSTOP以外的所有信号。

sigaction 头文件及原型

#include <signal.h>

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

sigaction 参数

signum： 注册信号的编号。

act：是一个结构体，如果不为空说明需要对该信号有新的配置。

struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};

结构体中void (*sa_sigaction)(int, siginfo_t *, void *); siginfo_t有下列的内容

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 */
  long     si_band;     /* Band event (was int in    glibc 2.3.2 and earlier) */
  int      si_fd;       /* File descriptor */
  short    si_addr_lsb; /* Least significant bit of address (since kernel 2.6.32) */
}

sigval_t si_value这个成员中有保存了发送过来的信息；在si_int或者si_ptr成员中也保存了对应的数据。si_int （整型）数据，sigval_t si_value 也是，value是一个结构体，int sival_int; void sival_ptr;
可以发一个整数* 也可以是字符串

oldact：如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。

sigqueue （信号发送函数）

sigaction 功能

在队列中向指定进程发送一个信号和数据。

sigaction 头文件及原型

#include <signal.h>

int sigqueue(pid_t pid, int sig, const union sigval value);

sigaction 参数

pid：目标进程的进程号
sig：信号代号
value：一个联合体，表示信号附带的数据，附带数据可以是一个整数也可以是一个指针，有如下形式：

union sigval {
int sival_int;
void *sival_ptr;//指向要传递的信号参数
};value

sigaction sigqueue 使用示例

sigaction

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

void sigaction_handler(int signum, siginfo_t* info, void* getBuf)
{
	printf("signum=%d\n",signum);
	printf("get from pid=%d\n",info->si_pid);
	
	if(getBuf!=NULL)
	{
		printf("info->si_int=%d\n",info->si_int);
		printf("info->si_value.sival_int=%d\n",info->si_int.sival_int);
	}
}

int main()
{
	printf("my pid=%d\n",getpid());
	
	struct sigaction act;
	act.sa_sigaction=sigaction_handler;
	act.sa_flags=SA_SGINFO;
	
	sigaction(SIGUSR1,&act,NULL);
	while(1);
	
	return 0;
}

sigqueue

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

int main(int argc,char** argv)
{
	if(argc!=3)
	{
		printf("please intput 3 param\n");
		exit(-1);
	}
	
	int signum;
	int pid;
	
	signum=atoi(argv[1]);
	pid=atoi(argv[2]);
	
	union sigval value;
	value.sival_int=100;
	
	sigqueue(pid,signum,value);
	
	return 0;
}

运行结果：

信号量（semget semop semctl）

信号量与上面的IPC结构不同，上面的IPC是可以发数据的，而信号量是不能发数据，它是一个计数器，信号量用于实现进程间的互斥与同步，而不是用于储存进程间通信数据。
Linux下的信号量函数都是在通用的信号量数组上进行操作，而不是 一个单一的二值信号量上进程操作
二值信号量：信号量只能取0或者1的变量

信号量特点

用于进程同步，如果是要进程间传递数据，需要和共享内存结合。
信号量是基于操作系统的PV操作，P（拿锁）V （放回锁）。
每次PV操作不仅限于对信号量值加1或者减1，可以加减任意的正整数。
支持信号量组。

semget（创建或者获取一个信号量组）

semctl（控制信号量的相关信息）

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

semop（对信号量组进行操作，改变信号量的值）

信号量 示例

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

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

void pGetKey(int semId)
{
	struct sembuf sem_b;
	sem_b.sem_num=0;
	sem_b.sem_op=-1;
	sem_b.sem_flg=SEM_UNDO;
	
	semop(semId,&sem_b,1);
	printf("get p key\n");
}

void vBackKey(int semId)
{
	struct sembuf sem_b;
	sem_b.sem_num=0;
	sem_b.sem_op=1;
	sem_b.sem_flg=SEM_UNDO;
	
	semop(semId,&sem_b,1);
	printf("Back v key\n");
}

int main()
{
	key_t key;
	key=ftok(".",6);
	
	int semId=semget(key,1,IPC_CREAT|0666);
	
	union semun initsem;
	initsem.val=0;
	semctl(semId,0,SETVAL,initsem);
	
	int retpid=fork();
	if(retpid>0)
	{
		pGetKey(semId);
		printf("this is father\n");
		vBackKey(semId);
	}
	else if(retpid==0)
	{
		printf("this is child\n");
		vBackKey(semId);
	}
	else
	{
		printf("fork error\n");
		exit(-1);
	}
	
	return 0;
}

运行结果：

这篇关于Linux 3.进程间通信（shmget shmat shmdt shmctl 共享内存、signal signaction sigqueue 信号、semget semctl semop 信号量）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！