Linux编程进程间通信

====IPC====
#include <unistd.h>
int pipe(int filedes[2]);
创建PIPIE，filedes[0]用于读，filedes[1]用于写，成功
返回0，－1失败；一般用于进程间的交互，比如shell之间
PIPE是一种单向的，容量有限制的流

#include <stdio.h>
FILE *popen(const char *command, const char *mode);
创建一个子进程执行SHELL命令，并建立和它之间的管道，返回
一个文件流，返回NULL出错
int pclose(FILE *stream);
关闭PIPE文件流, 返回子进程的状态，－1出错

include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
创建一个FIFO管道，成功返回0，－1出错
通常关联两个不相关的两个程序，共享数据,也和PIPE一样
容量有限的传输，不能用于大量的字节流

#include <sys/ipc.h>
key_t ftok(char *pathname, int proj);
创建一个唯一IPC KEY，返回0成功，－1出错

#include <sys/types.h> /* For portability */ #include <sys/msg.h>
int msgget(key_t key, int msgflg);
得到消息表示ID号，返回－1表示出错

#include <sys/types.h> /* For portability */ #include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
发送消息，返回0成功，－1出错

#include <sys/types.h> /* For portability */ #include <sys/msg.h>
ssize_t msgrcv(int msqid, void *msgp, size_t maxmsgsz, long msgtyp, int msgflg);
接受消息，返回拷贝的字节数，返回－1出错

#include <sys/types.h> /* For portability */ #include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
设置IPC MSG队列的控制选项，返回0成功，－1出错

#include <sys/types.h> /* For portability */ #include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
得到一个信号量ID值，返回－1出错

#include <sys/types.h> /* For portability */ #include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ... /* union semun arg */);
设置信号量的选项值，返回-1出错

#include <sys/types.h> /* For portability */ #include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned int nsops);
设置信号量的操作，返回0成功，－1出错

#include <sys/types.h> /* For portability */ #include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
得到共享内存的ID号，返回－1表示出错

#include <sys/types.h> /* For portability */ #include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
得到共享内存的地址信息，返回－1表示出错

#include <sys/types.h> /* For portability */ #include <sys/shm.h>
int shmdt(const void *shmaddr);
移除共享内存的相关信息，不在使用，返回－1出错，0成功

#include <sys/types.h> /* For portability */ #include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
设置共享内存的配置选项，返回0成功，－1出错

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
创建一份内存映射，返回MAP_FAILED 表示出错

#include <sys/mman.h>
int munmap(void *addr, size_t length);
解除内存映射，成功返回0，－1出错

#include <fcntl.h> /* Defines O_* constants */ #include <sys/stat.h> /* Defines mode constants */ #include <sys/mman.h>
int shm_open(const char *name, int oflag, mode_t mode);
创建或是打开已有的，共享内存对象，返回文件描述符，－1出错

#include <sys/mman.h>
int shm_unlink(const char *name);
移除共享内存对象，返回0成功，－1失败

====文件锁====
#include <sys/file.h>
int flock(int fd, int operation);
对文件进行operation类型的锁操作
1.LOCK_SH   放置共享锁
2.LOCK_EX   放置递归锁
3.LOCK_UN   解锁
4.LOCK_NB   无阻塞锁
操作成功返回0，失败返回－1值

====终端====
#include <termios.h>
int tcgetattr(int fd, struct termios *termios_p);
int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);
获取/设置终端的配置信息，返回0成功，－1失败

#include <termios.h>
speed_t cfgetispeed(const struct termios *termios_p);
speed_t cfgetospeed(const struct termios *termios_p);
获取终端波特率
int cfsetospeed(struct termios *termios_p, speed_t speed);
int cfsetispeed(struct termios *termios_p, speed_t speed);
设置波特率，成功返回0，-1失败

#include <termios.h>
int tcsendbreak(int fd, int duration);
int tcdrain(int fd);
int tcflush(int fd, int queue_selector);
int tcflow(int fd, int action);
终端行控制函数，返回0成功，-1失败

#include <unistd.h>
int isatty(int fd);
判断是否为一个终端，返回1是，0不是

#include <unistd.h>
char *ttyname(int fd);
返回终端的名称，返回NULL表示出错

#define _XOPEN_SOURCE 600
#include <stdlib.h>
#include <fcntl.h>
int posix_openpt(int flags);
打开一个没被使用的伪终端，返回文件描述符，返回－1出错

#define _XOPEN_SOURCE 500
#include <stdlib.h>
int grantpt(int mfd);
授权终端，用于兼容以前的模式，成功返回0，失败返回－1值

#define _XOPEN_SOURCE 500
#include <stdlib.h>
int unlockpt(int mfd);
解锁pseudoterminal master，用于能够创建pseudoterminal slave
错误返回－1，成功返回0值

#define _XOPEN_SOURCE 500
#include <stdlib.h>
char *ptsname(int mfd);
得到pseudoterminal slave的终端名称

====高级IO====
#include <sys/time.h> /* For portability */
#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
    fd_set *exceptfds, struct timeval *timeout);
多路转接复用，告诉内核关心的文件描述符，当它们中的一个或是多个
准备好了，便返回给调用者
nfds        最大描述符＋1
readfds     可读的文件描述符集合
writefds    可写的文件描述符集合
exceptfds   处理异常的文件描述符集合
timeout     ==NULL,永远等待，直到捕获信号，或是关心的文件描述已经准备好了
            !=NULL,如果tv_sec==0&&tv_usec==0，测试后立即返回，否则等待指定的时间
返回准备就绪的文件描述符数，超时返回0，返回－1表示出错

#include <sys/select.h>
void FD_ZERO(fd_set *fdset);
void FD_SET(int fd, fd_set *fdset);
void FD_CLR(int fd, fd_set *fdset);
int FD_ISSET(int fd, fd_set *fdset);
清空文件描述符集合
添加文件描述符到集合中
从集合中移除文件描述符
测试文件描述符是否存在集合内，返回1存在，0不存在

#include <poll.h>
int poll(struct pollfd fds[], nfds_t nfds, int timeout);
作用类似select函数，但它更简洁，只构造一个文件描述符数组，每个
元素指定文件描述符和关心的状态，函数返回就绪的文件描述符数，返回
0表示超时，－1出错

上述两个函数的缺点：
1.是必须轮询所有的文件描述符集合/数组
2.每次调用都必须传递文件描述符相关信息给内核，内核修改状态
后返回
3.返回后，函数需要检查哪些文件描述符是已经就绪

 

 

转载于:https://www.cnblogs.com/y2ghost/p/4363506.html