什么是进程

【资料图】

1、进程和线程的区别

进程是指正在运行的程序，它拥有独立的内存空间和系统资源，不同进程之间的数据不共享。进程是资源分配的基本单位。

线程是进程内的执行单元，它与同一进程内的其他线程共享进程的内存空间和系统资源。线程是调度的基本单位。

2、进程的创建和销毁

在Linux中启动一个进程有多种方法：

（1）通过system函数启动进程。（使用简单，效率较低）

#include/***@brief执行系统命令调用命令处理器来执行命令**Detailedfunctiondescription**@param[in]command:包含被请求变量名称的C字符串**@return如果发生错误，则返回值为-1，否则返回命令的状态。*/intsystem(constchar*command);

例子：通过system函数启动一个进程，列出当前目录下的文件及文件夹。

#include#includeintmain(void){system("ls");printf("lsend");return0;}

（2）通过fork函数启动进程。（用于启动子进程）

#include#include/***@brieffork系统调用用于创建一个子进程**Detailedfunctiondescription**@param[in]**@return如果发生错误，则返回值为-1，否则返回命令的状态。*/pid_tfork(void);

例子：通过fork函数启动子进程

#include#include#include#includeintmain(void){pid_tres=fork();///<子进程if(res==0){printf("res=%d,Iamchildprocess.pid=%d",res,getpid());exit(EXIT_SUCCESS);///<正常退出子进程}///<父进程elseif(res>0){printf("res=%d,Iamparentprocess.pid=%d",res,getpid());intchild_status=0;pid_tchild_pid=wait(&child_status);///<父进程阻塞等待信号到来或子进程结束printf("Childprocess(pid=%d)hasbeenterminated,child_status=%d",child_pid,child_status);}///<异常退出else{printf("Forkfailed.");exit(EXIT_FAILURE);}return0;}

编译、运行：

我们使用了fork()系统调用来创建一个新进程。如果fork()返回值为0，则说明当前进程是子进程；如果返回值大于0，则说明当前进程是父进程。在父进程中，我们使用wait()系统调用来等待子进程结束。当子进程结束后，父进程会继续执行。

（3）通过exec系列函数启动进程。（用于启动新进程，新进程会覆盖旧进程）

#include/***@brief启动新进程，新进程会覆盖旧进程**Detailedfunctiondescription**@param[in]path:所执行文件的路径*@param[in]file:所执行文件的名称*@param[in]arg:传入的参数列表，以NULL作为结束*@param[in]envp:传入的环境变量**@return如果发生错误，则返回值为-1，否则返回命令的状态。*/intexecl(constchar*path,constchar*arg,...);intexeclp(constchar*file,constchar*arg,...);intexecle(constchar*path,constchar*arg,...,char*constenvp[]);intexecv(constchar*path,char*constargv[]);intexecvp(constchar*file,char*constargv[]);intexecve(constchar*path,char*constargv[],char*constenvp[]);

例子：通过execl()函数的参数列表调用了ls命令程序

#include#includeintmain(void){execl("/bin/ls","ls","-la",NULL);printf("lsend");return0;}

execl()函数的参数列表调用了ls命令程序，与在终端上运行”ls -la”产生的结果是一样的。

在Linux中终止一个进程有多种方法：

从main函数返回。（正常终止）

调用exit()函数终止。（正常终止）

调用_exit()函数终止。（正常终止）

调用abort()函数终止。（异常终止）

由系统信号终止。（异常终止）

进程间通信方式

进程间通信是指在不同进程之间传播或交换信息的一种机制。每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷到内核缓冲区，进程B再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。

进程间通信的目的：

传输数据。比如进程 A 负责生成数据，进程 B 负责处理数据，数据需要从 A 进程传输至 B 进程。

共享资源。比如进程 A 与进程 B 共享某一块内存资源。

模块化。将系统功能划分为多个进程模块进行开发，方便开发维护。

加速计算。多核处理器环境，一个特定进程划分为几个进程并行运行。

Linux IPC（Inter-process Comminication， 进程间通信）的方式：

1、消息队列

内核中的一个优先级队列，多个进程通过访问同一个队列，进行添加结点或者获取结点实现通信。

POSIX消息队列头文件：

#include/*ForO_*constants*/#include/*Formodeconstants*/#include

编译链接需要加上 -lrt 链接。

消息队列API接口：

/***@brief创建消息队列实例**Detailedfunctiondescription**@param[in]name:消息队列名称*@param[in]oflag：根据传入标识来创建或者打开一个已创建的消息队列-O_CREAT:创建一个消息队列-O_EXCL:检查消息队列是否存在，一般与O_CREAT一起使用-O_CREAT|O_EXCL:消息队列不存在则创建，已存在返回NULL-O_NONBLOCK:非阻塞模式打开，消息队列不存在返回NULL-O_RDONLY:只读模式打开-O_WRONLY:只写模式打开-O_RDWR:读写模式打开*@param[in]mode：访问权限*@param[in]attr：消息队列属性地址**@return成功返回消息队列描述符，失败返回-1，错误码存于error中*/mqd_tmq_open(constchar*name,intoflag,mode_tmode,structmq_attr*attr);/***@brief无限阻塞方式接收消息**Detailedfunctiondescription**@param[in]mqdes:消息队列描述符*@param[in]msg_ptr：消息体缓冲区地址*@param[in]msg_len：消息体长度，长度必须大于等于消息属性设定的最大值*@param[in]msg_prio：消息优先级**@return成功返回消息长度，失败返回-1，错误码存于error中*/mqd_tmq_receive(mqd_tmqdes,char*msg_ptr,size_tmsg_len,unsigned*msg_prio);/***@brief指定超时时间阻塞方式接收消息**Detailedfunctiondescription**@param[in]mqdes:消息队列描述符*@param[in]msg_ptr：消息体缓冲区地址*@param[in]msg_len：消息体长度，长度必须大于等于消息属性设定的最大值*@param[in]msg_prio：消息优先级*@param[in]abs_timeout：超时时间**@return成功返回消息长度，失败返回-1，错误码存于error中*/mqd_tmq_timedreceive(mqd_tmqdes,char*msg_ptr,size_tmsg_len,unsigned*msg_prio,conststructtimespec*abs_timeout);/***@brief无限阻塞方式发送消息**Detailedfunctiondescription**@param[in]mqdes:消息队列描述符*@param[in]msg_ptr：待发送消息体缓冲区地址*@param[in]msg_len：消息体长度*@param[in]msg_prio：消息优先级**@return成功返回0，失败返回-1*/mqd_tmq_send(mqd_tmqdes,constchar*msg_ptr,size_tmsg_len,unsignedmsg_prio);/***@brief指定超时时间阻塞方式发送消息**Detailedfunctiondescription**@param[in]mqdes:消息队列描述符*@param[in]msg_ptr：待发送消息体缓冲区地址*@param[in]msg_len：消息体长度*@param[in]msg_prio：消息优先级*@param[in]abs_timeout：超时时间**@return成功返回0，失败返回-1*/mqd_tmq_timedsend(mqd_tmqdes,constchar*msg_ptr,size_tmsg_len,unsignedmsg_prio,conststructtimespec*abs_timeout);/***@brief关闭消息队列**Detailedfunctiondescription**@param[in]mqdes:消息队列描述符**@return成功返回0，失败返回-1*/mqd_tmq_close(mqd_tmqdes);/***@brief分离消息队列**Detailedfunctiondescription**@param[in]name:消息队列名称**@return成功返回0，失败返回-1*/mqd_tmq_unlink(constchar*name);

消息队列基本API接口使用例子：发送进程给接收进程发送测试数据。

send.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#defineMQ_MSG_MAX_SIZE512///<最大消息长度#defineMQ_MSG_MAX_ITEM5///<最大消息数目staticmqd_ts_mq;typedefstruct_msg_data{charbuf[128];intcnt;}msg_data_t;voidsend_data(void){staticintcnt=0;msg_data_tsend_data={0};cnt++;strcpy(send_data.buf,"hello");send_data.cnt=cnt;intret=mq_send(s_mq,(char*)&send_data,sizeof(send_data),0);if(ret<0){perror("mq_senderror");return;}printf("sendmsg=%s,cnt=%d",send_data.buf,send_data.cnt);}intmain(void){intret=0;structmq_attrattr;///<创建消息队列memset(&attr,0,sizeof(attr));attr.mq_maxmsg=MQ_MSG_MAX_ITEM;attr.mq_msgsize=MQ_MSG_MAX_SIZE;attr.mq_flags=0;s_mq=mq_open("/mq",O_CREAT|O_RDWR,0777,&attr);if(-1==s_mq){perror("mq_openerror");return-1;}for(size_ti=0;i<10;i++){send_data();sleep(1);}mq_close(s_mq);return0;}

recv.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#defineMQ_MSG_MAX_SIZE512///<最大消息长度#defineMQ_MSG_MAX_ITEM5///<最大消息数目staticmqd_ts_mq;typedefstruct_msg_data{charbuf[128];intcnt;}msg_data_t;intmain(void){intret=0;structmq_attrattr;charrecv_msg[MQ_MSG_MAX_SIZE]={0};msg_data_trecv_data={0};intprio=0;ssize_tlen=0;s_mq=mq_open("/mq",O_RDONLY);if(-1==s_mq){perror("mq_openerror");return-1;}while(1){if((len=mq_receive(s_mq,(char*)&recv_data,MQ_MSG_MAX_SIZE,&prio))==-1){perror("mq_receiveerror");return-1;}printf("recv_msg=%s,cnt=%d",recv_data.buf,recv_data.cnt);sleep(1);}mq_close(s_mq);mq_unlink("/mq");return0;}

编译、运行：

gccsend.c-osend_process-lrtgccrecv.c-orecv_process-lrt

2、共享内存

消息队列的读取和写入的过程，会有发生用户态与内核态之间的消息拷贝过程。而共享内存的方式则没有这个拷贝过程，进程间通信速度较快。

在物理内存上开辟一块内存空间，多个进程可以将同一块物理内存空间映射到自己的虚拟地址空间，通过自己的虚拟地址直接访问这块空间，通过这种方式实现数据共享。

POSIX共享内存头文件：

#include#include#include

共享内存API接口：

/***@brief创建共享内存实例**Detailedfunctiondescription**@param[in]name:要打开或创建的共享内存文件名*@param[in]oflag：打开的文件操作属性-O_CREAT:创建一个共享内存文件-O_EXCL:检查共享内存是否存在，一般与O_CREAT一起使用-O_CREAT|O_EXCL:共享内存不存在则创建，已存在返回NULL-O_NONBLOCK:非阻塞模式打开，共享内存不存在返回NULL-O_RDONLY:只读模式打开-O_WRONLY:只写模式打开-O_RDWR:读写模式打开*@param[in]mode：文件共享模式，例如0777**@return成功返回共享内存描述符，失败返回-1，错误码存于error中*/intshm_open(constchar*name,intoflag,mode_tmode);/***@brief删除共享内存**Detailedfunctiondescription**@param[in]name:创建的共享内存文件名**@return成功返回0，失败返回-1*/intshm_unlink(constchar*name);/***@brief将打开的文件映射到内存**Detailedfunctiondescription**@param[in]addr:要将文件映射到的内存地址，一般应该传递NULL来由Linux内核指定*@param[in]length:要映射的文件数据长度*@param[in]prot:映射的内存区域的操作权限（保护属性），包括PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE*@param[in]flags:标志位参数，包括：MAP_SHARED、MAP_PRIVATE与MAP_ANONYMOUS。*@param[in]fd:用来建立映射区的文件描述符，用shm_open打开或者open打开的文件*@param[in]offset:映射文件相对于文件头的偏移位置，应该按4096字节对齐**@return成功返回0，失败返回-1*/void*mmap(void*addr,size_tlength,intprot,intflags,intfd,off_toffset);/***@brief取消内存映射**Detailedfunctiondescription**@param[in]addr:由mmap成功返回的地址*@param[in]length:要取消的内存长度**@return成功返回0，失败返回-1*/intmunmap(void*addr,size_tlength);/***@brief将参数fd指定的文件大小改为参数length指定的大小**Detailedfunctiondescription**@param[in]fd:已打开的文件描述符，以写入模式打开的文件*@param[in]length:要设置的长度**@return成功返回0，失败返回-1*/intftruncate(intfd,off_tlength);/***@brief获取文件相关的信息，将获取到的信息放入到statbuf结构体中**Detailedfunctiondescription**@param[in]fd:已打开的文件描述符*@param[out]statbuf:文件的信息**@return成功返回0，失败返回-1*/intfstat(intfd,structstat*statbuf);

共享内存基本API接口使用例子：发送进程给接收进程发送测试数据。

send.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#defineSHM_NAME"/shm"intmain(void){intret=0;///<创建和读端相同的文件标识intshm_fd=shm_open(SHM_NAME,O_RDWR|O_CREAT,0666);if(shm_fd==-1){printf("shm_openerror");}///<设置共享内存文件为8KBftruncate(shm_fd,8*1024);///<获取共享内存文件相关属性信息structstatfilestat={0};fstat(shm_fd,&filestat);printf("st_size=%ld",filestat.st_size);///<内存映射char*shm_ptr=(char*)mmap(NULL,filestat.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,shm_fd,0);close(shm_fd);///<向共享内存中写入数据charbuf[]="helloworld";memmove(shm_ptr,buf,sizeof(buf));printf("pid%d,%s",getpid(),shm_ptr);///<写入完成后解除映射munmap(shm_ptr,filestat.st_size);return0;}

recv.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#defineSHM_NAME"/shm"intmain(void){///<创建共享内存文件标识符intshm_fd=shm_open(SHM_NAME,O_RDWR|O_CREAT,0666);if(shm_fd==-1){printf("shm_openfailed");exit(EXIT_FAILURE);}///<设置共享内存文件为8KBftruncate(shm_fd,8192);///<获取共享内存文件相关属性信息structstatfilestat;fstat(shm_fd,&filestat);printf("st_size=%ld",filestat.st_size);///<映射共享内存，并获取共享内存的地址char*shm_ptr=(char*)mmap(NULL,filestat.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,shm_fd,0);close(shm_fd);///<获取共享内存地址中的内容并打印，最后再解除映射，删除共享内存printf("pid=%d，%s",getpid(),shm_ptr);munmap(shm_ptr,filestat.st_size);shm_unlink(SHM_NAME);return0;}

编译、运行：

gccsend.c-osend_process-lrtgccrecv.c-orecv_process-lrt

对具有多个处理核系统消息传递的性能要优于共享内存。共享内存会有高速缓存一致性问题，这是由共享数据在多个高速缓存之间迁移而引起的。随着系统的处理核的数量的日益增加，可能导致消息传递作为 IPC 的首选机制。

3、socket

UNIX域套接字与传统基于TCP/IP协议栈的socket不同，unix domain socket以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。

unix domain socket在进程间通信同样是基于“客户端—服务器”（C-S）模式。

UNIX域套接字基本API接口使用例子：基于UNIX域套接字客户端进程向服务端进程发送测试数据。

server.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#include#include#include#defineSERVER_PATH"/tmp/server"intmain(void){///<创建UNIX域字节流套接字intserver_fd=socket(AF_LOCAL,SOCK_STREAM,0);if(server_fd<0){printf("socketerror");exit(EXIT_FAILURE);}///<绑定服务端地址unlink(SERVER_PATH);structsockaddr_unserver_addr;memset((char*)&server_addr,0,sizeof(server_addr));server_addr.sun_family=AF_LOCAL;strncpy(server_addr.sun_path,SERVER_PATH,sizeof(server_addr.sun_path)-1);if(bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr))<0){printf("binderror");close(server_fd);exit(EXIT_FAILURE);}///<监听if(listen(server_fd,10)<0){printf("listenerror");close(server_fd);exit(EXIT_FAILURE);}///<等待客户端连接intaddr_len=sizeof(structsockaddr);structsockaddr_unclient_addr;intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,(socklen_t*)&addr_len);if(client_fd<0){printf("accepterror");close(server_fd);unlink(SERVER_PATH);exit(1);}else{printf("connectedclient:%s",client_addr.sun_path);}while(1){charbuf[128]={0};intrecv_len=read(client_fd,buf,sizeof(buf));if(recv_len<=0){printf("recverror!");close(client_fd);exit(EXIT_FAILURE);}printf("recv:%s",buf);}unlink(SERVER_PATH);close(server_fd);close(client_fd);return0;}

client.c：

#include#include#include#include#include/*ForO_*constants*/#include/*Formodeconstants*/#include#include#include#include#defineSERVER_PATH"/tmp/server"#defineCLIENT_PATH"/tmp/client"intmain(void){///<创建UNIX域字节流套接字intclient_fd=socket(AF_UNIX,SOCK_STREAM,0);if(client_fd<0){printf("socketerror");exit(EXIT_FAILURE);}///<显式绑定客户端地址structsockaddr_unclient_addr;memset((char*)&client_addr,0,sizeof(client_addr));client_addr.sun_family=AF_UNIX;strncpy(client_addr.sun_path,CLIENT_PATH,sizeof(client_addr.sun_path)-1);unlink(CLIENT_PATH);if(bind(client_fd,(structsockaddr*)&client_addr,sizeof(client_addr))<0){printf("binderror");close(client_fd);exit(1);}///<连接服务端structsockaddr_unserver_addr;server_addr.sun_family=AF_UNIX;strncpy(server_addr.sun_path,SERVER_PATH,sizeof(server_addr.sun_path)-1);intret=connect(client_fd,(structsockaddr*)&server_addr,sizeof(server_addr));if(ret<0){printf("connecterror");close(client_fd);unlink(CLIENT_PATH);exit(1);}printf("connecttoserver:%s",server_addr.sun_path);while(1){charbuf[128]={0};if(scanf("%s",buf)){intsend_len=write(client_fd,buf,strlen(buf));if(send_len<=0){printf("writeerror!");close(client_fd);exit(EXIT_FAILURE);}else{printf("sendsuccess!send:%s,send_len:%d",buf,send_len);}}}unlink(SERVER_PATH);close(client_fd);return0;}

编译、运行：

gccserver.c-oserver_processgccclient.c-oclient_process

类socket的其它进程间通信方式：

实用 | nanomsg通信库的简单使用分享

mqtt应用于进程间通信

4、管道

在内核中开辟一块缓冲区；若多个进程拿到同一个管道(缓冲区)的操作句柄，就可以访问同一个缓冲区，就可以进行通信。涉及到两次用户态与内核态之间的数据拷贝。

（1）匿名管道

内核中的缓冲区是没有具体的标识符的，匿名管道只能用于具有亲缘关系的进程间通信。

调用pipe接口可以创建一个匿名管道，并返回了两个描述符，一个是管道的读取端描述符 fd[0]，另一个是管道的写入端描述符 fd[1]。

管道是一个半双工通信(可以选择方向的单向传输)

匿名管道基本API接口使用例子：父进程通过管道发送测试数据给子进程。

#include#include#include#includeintmain(){///<创建管道intpipefd[2]={-1};intret=pipe(pipefd);if(ret<0){printf("pipeerror");exit(EXIT_FAILURE);}intread_fd=pipefd[0];///0){///<父进程向管道写入数据char*ptr="hello88888888";write(write_fd,ptr,strlen(ptr));}return0;}

编译、运行：

如果需要双向通信，则应该创建两个管道。

（2）命名管道

命名管道也是内核中的一块缓冲区，并且这个缓冲区具有标识符；这个标识符是一个可见于文件系统的管道文件，能够被其他进程找到并打开管道文件，则可以获取管道的操作句柄，所以该命名管道可用于同一主机上的任意进程间通信。

创建命名管道的接口：

intmkfifo(constchar*pathname,mode_tmode);

命名管道基本API接口使用例子：一个进程往管道中写入测试数据，另一个进程从管道中读取数据。

fifo_wr.c：

#include#include#include#include#include#include#include#defineFIFO_PATH"./fifo_file"typedefstruct_msg_data{charbuf[128];intcnt;}msg_data_t;voidsend_data(intfd){staticintcnt=0;msg_data_tsend_data={0};cnt++;strcpy(send_data.buf,"hello");send_data.cnt=cnt;write(fd,&send_data,sizeof(send_data));printf("sendmsg=%s,cnt=%d",send_data.buf,send_data.cnt);}intmain(void){///<创建管道文件intret=mkfifo(FIFO_PATH,0664);if(ret<0&&errno!=EEXIST){printf("mkfifoerror");exit(EXIT_FAILURE);}///<以只写的方式打开管道文件intfd=open(FIFO_PATH,O_WRONLY);if(fd<0){printf("openfifoerror");exit(EXIT_FAILURE);}printf("openfifosuccess");///<写10次for(size_ti=0;i<10;i++){send_data(fd);sleep(1);}close(fd);return0;}

fifo_rd.c：

#include#include#include#include#include#include#include#defineFIFO_PATH"./fifo_file"typedefstruct_msg_data{charbuf[128];intcnt;}msg_data_t;intmain(void){umask(0);///<创建管道文件intret=mkfifo(FIFO_PATH,0664);if(ret<0&&errno!=EEXIST){printf("mkfifoerror");exit(EXIT_FAILURE);}///<以只读方式获取管道文件的操作句柄intfd=open(FIFO_PATH,O_RDONLY);if(fd<0){printf("openerror");exit(EXIT_FAILURE);}printf("openfifosuccess");while(1){msg_data_tread_data={0};///<将从管道读取的文件写到buf中intret=read(fd,&read_data,sizeof(read_data));if(ret<0){printf("readerror");exit(EXIT_FAILURE);}elseif(ret==0){printf("allwriteclosedd");exit(EXIT_FAILURE);}printf("read_data=%s,cnt=%d",read_data.buf,read_data.cnt);sleep(1);}close(fd);return0;}

编译、运行：

gccfifo_wr.c-ofifo_wrgccfifo_rd.c-ofifo_rd

5、信号量

信号量（Seamphore）是进程和线程间同步的一种机制。

信号量本质是一个非负的整型变量。增加一个可用资源执行加一，也称为V操作；获取一个资源资源后执行减一，也称为P操作。

信号量根据信号值不同可分为两类：

二值信号量，信号量值只有0和1，初始值为1，1表示资源可用，0表示资源不可用；二值信号量与互斥锁类似。

计数信号量， 信号量的值在0到一个大于1的限制值之间，信号值表示可用的资源的数目。

信号量根据作用对象不同可分为两类：

有名信号量，信号值保存在文件中，用于进程间同步

无名信号量，又称为基于内存信号量，信号值保存在内存中，用于线程间同步

POSIX信号量头文件：

#include

编译链接需要加-lpthread参数。

信号量API接口：

/***@brief创建信号量**Detailedfunctiondescription**@param[in]name:信号量名称*@param[in]mode:访问权限*@param[in]value:信号量初始值**@return成功时返回指向信号量的指针，出错时为SEM_FAILED*/sem_t*sem_open(constchar*name,intoflag,mode_tmode,unsignedintvalue);/***@brief初始化信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址*@param[in]pshared:信号量作用域，分为进程内作用域PTHREAD_PROCESS_PRIVATE和跨进程作用域PTHREAD_PROCESS_SHARED*@param[in]value:信号量初始值**@return成功返回0，失败返回-1*/intsem_init(sem_t*sem,intpshared,unsignedintvalue);/***@brief获取信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址*@param[out]sval:保存返回信号值地址**@return成功返回0，失败返回-1*/intsem_getvalue(sem_t*sem,int*sval);/***@brief阻塞方式等待信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址**@return成功返回0，失败返回-1*/intsem_wait(sem_t*sem);/***@brief指定超时时间阻塞方式等待信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址*@param[in]sem:超时时间，单位为时钟节拍**@return成功返回0，失败返回-1*/intsem_timedwait(sem_t*sem,conststructtimespec*abs_timeout);/***@brief非阻塞方式等待信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址**@return成功返回0，失败返回-1*/intsem_trywait(sem_t*sem);/***@brief产生信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址**@return成功返回0，失败返回-1*/intsem_post(sem_t*sem);/***@brief销毁信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址**@return成功返回0，失败返回-1*/intsem_destroy(sem_t*sem);/***@brief关闭信号量**Detailedfunctiondescription**@param[in]sem:信号量实例地址**@return成功返回0，失败返回-1*/intsem_close(sem_t*sem);/***@brief分离信号量**Detailedfunctiondescription**@param[in]name:信号量名称**@return成功返回0，失败返回-1*/intsem_unlink(constchar*name);

信号量基本API接口使用例子：父子进程间通信

#include#include#include#include#include#defineSEM_NAME"sem"intmain(void){intsem_val=0;///<创建信号量sem_t*sem=sem_open(SEM_NAME,O_CREAT,0666,1);if(NULL==sem){printf("sem_openerror");exit(EXIT_FAILURE);}///<创建子进程pid_tpid=fork();if(pid==-1){printf("forkerror");sem_close(sem);sem_unlink(SEM_NAME);exit(EXIT_FAILURE);}elseif(pid==0){///<子进程进行5次P操作for(size_ti=0;i<5;i++){sem_wait(sem);if(sem_getvalue(sem,&sem_val)!=-1){printf("childprocessPoperation,sem_val=%d",sem_val);sleep(1);}}_exit(1);}elseif(pid>0){///<父进程执行5次V操作for(size_ti=0;i<5;i++){sem_post(sem);if(sem_getvalue(sem,&sem_val)!=-1){printf("prarentprocessVoperation,sem_val=%d",sem_val);sleep(2);}}}///<删除sem信号量sem_close(sem);if(sem_unlink(SEM_NAME)!=-1){printf("sem_unlinksuccess");}return0;}

编译、运行：

IPC总结

操作系统根据不同的场景提供了不同的方式，消息队列、共享内存、UNIX域套接字、管道、信号量。

消息队列：内核中的一个优先级队列，多个进程通过访问同一个队列，在队列当中添加或者获取节点来实现进程间通信。

共享内存：本质是一块物理内存，多个进程将同一块物理内存映射到自己的虚拟地址空间中，再通过页表映射到物理地址达到进程间通信，它是最快的进程间通信方式，相较其他通信方式少了两步数据拷贝操作。

UNIX域套接字：与TCP/IP套接字使用方式相同，但UNIX域套接字以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。

管道：内核中的一块缓冲区，分为匿名管道和命名管道。匿名管道只能用于具有亲缘关系的进程间；而命名管道可用于同一主机上任意进程间通信。

信号量：本质是内核中的一个计数器，主要实现进程间的同步与互斥，对资源进行计数，有两种操作，分别是在访问资源之前进行的p操作，还有产生资源之后的v操作。

审核编辑：汤梓红