Linux系统编程-进程间通信

已于 2022-03-24 13:58:00 修改
阅读量480 收藏 1
点赞数 1
分类专栏： linux C语言 文章标签： 学习 linux c语言
于 2022-03-23 16:10:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43239805/article/details/123688967
版权

进程间通信 

无名管道

1. 只能用于有关联的进程间数据交互，如父子进程，兄弟进程，子孙进程，在目录中看不到文件节点，读写文件描述符存在一个 int 型数组中。 2. 只能单向传输数据，即管道创建好后，一个进程只能进行读操作，另一个进程只能进行写操作，读出来字节顺序和写入的顺序一样。

  1. 调用 pipe()创建无名管道；
  2. fork()创建子进程，一个进程读，使用 read()，一个进程写，使用 write()。

pipe()：创建无名管道： 
#include <unistd.h> 
int pipe(int pipefd[2]); 
参数含义： 一个 int 型数组，表示管道的文件描述符，pipefd[0]为读，pipefd[1]为写，
返回值：成功返回 0，失败返回-1。

#include <unistd.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#define LEN 32 
int main(int argc, const char *argv[]) 
{ 
    int ret; 
    int fd[2]; 
    pid_t pid; 
    char buff[LEN]; 
    ret = pipe(fd);//创建无名管道 
    if(-1 == ret)
    { 
        perror("pipe"); 
        return -1; 
    }
    pid = fork(); 
    if(pid < 0)
    { 
        perror("fork"); 
        return -1; 
    }else if(pid == 0)
    { 
        while(1)
        { 
            memset(buff,0,LEN); 
            ret = read(fd[0],buff,LEN);//从管道读 
            if(ret < 0) 
                continue; 
            printf("fd[0]: %s\n",buff); 
        } 
    }else if(pid > 0)
    {
        char str[LEN]; 
        while(1)
        { 
            fgets(str,LEN,stdin); 
            ret = write(fd[1],str,LEN);//向管道写入 
        } 
    }
    return 0; 
}

/*
有名管道 
1.可以使无关联的进程通过 fifo 文件描述符进行数据传递； 
2.单向传输有一个写入端和一个读出端，操作方式和无名管道相同。
- 使用 mkfifo()创建 fifo 文件描述符。
- 打开管道文件描述符。
- 通过读写文件描述符进行单向数据传输。
mkfifo()：创建有名管道使用， 
#include <sys/types.h> 
#include <sys/stat.h> 
int mkfifo(const char *pathname, mode_t mode); 
参数含义： 
pathname：有名管道的路径和名称； 
mode：权限。 
返回值：成功返回 0，失败返回-1。
*/
#include <stdio.h> 
#include <sys/types.h> 
#include <unistd.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#define LEN 16 
int main(int argc, const char *argv[]) 
{ 
    int fd; 
    char buff[16]; 
    unlink("./topeet");//取消链接 
        if(-1 == mkfifo("./topeet",0666))
    { 
        perror("mkfifo"); return -1; 
    }
    fd = open("./topeet",O_WRONLY);//打开管道文件描述符 
        if(fd < 0)
    { 
        perror("open"); 
        return -1; 
    }
        while(1)
    { 
        fgets(buff,LEN,stdin); 
        write(fd,buff,LEN);//写管道 
    }
    return 0; 
    }

#include <stdio.h> 
#include <sys/types.h> 
#include <unistd.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <string.h> 
#define LEN 16 
int main(int argc, const char *argv[]) 
{ 
    int fd; 
    ssize_t size; 
    char buff[LEN]; 
    fd = open("./topeet",O_RDONLY);//打开管道文件描述符 
        if(fd < 0)
    { 
        perror("open"); 
        return -1; 
    }
        while(1)
    { 
            memset(buff,0,LEN); 
            size = read(fd,buff,LEN);//读管道 
            if(size > 0)
        { 
            printf("Read: %s\n",buff); 
        } 
    }
    return 0; 
}

 信号

信号处理方式

1.默认方式（通常是终止进程）。

2.忽略，不进行任何操作。 3.捕捉并处理调用信号处理器（回调函数形式）。

kill -l :

> 1)SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
> 6)SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
> 11)SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
> 16)SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
> 21)SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
> 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR 
> 31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3

/*
信号处理函数： 
signal()：改变收到信号后的动作。 
#include <signal.h> 
typedef void (*sighandler_t)(int); 
sighandler_t signal(int signum, sighandler_t handler); 
函数功能：信号 signum 发送后执行 handler。 
参数含义： 
signum：要捕获的信号类型。 
handler：对信号的处理操作，三种处理方式如下： 忽略该信号，
填写“SIG_IGN”； 采用系统默认方式处理该信号，
填写“SIG_DFL”； 捕获到信号后执行此函数内容，
    定义格式为“typedef void (*sighandler_t)(int)”，
    sighandler_t 代表一个 函数指针。 
返回值：
调用成功返回最后一次注册信号调用 signal()时的 handler 值；
失败返回 SIG_ERR。 
kill()：发送信号 
#include <sys/types.h>
#include <signal.h> 
int kill(pid_t pid, int sig); 
参数含义： 
pid：
    大于 0，时为向 PID 为 pid 的进程发送信号； 
    等于 0，向同一个进程组的进程发送信号； 
    等于-1，除发送进程自身外，向所有进程 ID 大于 1 的进程发送信号。 
    小于-1，向组 ID 等于该 pid 绝对值的进程组内所有进程发送信号。 
sig：设置发送的信号；
    等于 0 时为空信号，无信号发送。常用来进行错误检查。 
返回值：
    执行成功时，返回值为 0；
    错误时，返回-1，并设置相应的错误代码 errno。
    
raise()：向进程自身发送信号： 
#include <signal.h> 
int raise(int sig); 
sig：信号。 
函数功能：相当于 kill(getpid(),sig)。

pause()：暂停进程，等待信号中断。 
#include <unistd.h> 
int pause(void); 
返回值：进程被信号中断后一直返回-1， 
函数功能：将进程挂起，等待信号。
 
alarm()：定时 
#include <unistd.h> 
unsigned int alarm(unsigned int seconds); 
参数含义：设定的时间 
函数功能：设定的时间超过后产生 SIGALARM 信号，默认动作是终止进程。 
使用规则：每个进程只能有一个 alarm()函数，时间到后要想再次使用要重新注册。
*/

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <signal.h> 
int count=0; 
void winHandle(int sig) 
{ 
    printf("window change %d !\n",count); 
        if(sig == SIGWINCH)
    { 
    //如果窗口大小改变次数+1 
        count++; 
    }
        if(count ==3)
    {
        //如果改变三次，程序结束。 
        raise(SIGKILL); 
    } 
}
int main(int argc, const char *argv[]) 
{ 
    signal(SIGWINCH,winHandle);//信号 SIGWINCH 发生后执行 winHandle 函数 
    while(1) 
        sleep(5); 
    return 0; 
}

#include <stdio.h> 
#include <signal.h> 
#include <unistd.h> 
void timeOut(int sig) 
{ 
    printf("topeet\n"); 
    alarm(2); 
}
int main(int argc, const char *argv[]) 
{ 
    alarm(2); 
    signal(SIGALRM,timeOut); 
    while(1); 
    return 0; 
}

消息队列

消息队列的使用步骤： 
1. 创建 key； 
2. msgget()通过 key 创建（或打开）消息队列对象 id； 
3. 使用 msgsnd()/msgrcv()进行收发；
4. 通过 msgctl()删除 ipc 对象

ftok()：获取 key，定义如下： 
#include <sys/types.h> 
#include <sys/ipc.h> 
key_t ftok(const char *pathname, int proj_id); 
参数含义：
pathname：路径名或文件名。 
proj_id：同一个文件根据此值生成多个 key 值，int 型或字符型，多个若想访问同一 IPC 对象，此值必须

msgget()：获取 IPC 对象唯一标识 id，定义如下： 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 
int msgget(key_t key, int msgflg); 
参数含义： 
key：通过 ftok 或 IPC_PRIVATE 获取的 key 值；
msgflg：指定匹配的结构，通常使用 IPC_CREAT。

msgsnd()：发送数据 
#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：IPC 对象对应的 id； 
msgp：消息指针，消息包含类型和字段； 
msgsz：传输字段的大小，不算消息中的类型 type 占的内容；
struct msgbuf 
{ 
    long mtype; /* message type, must be > 0 */ 
    char mtext[1]; /* message data */ 
}; 
其中
mtype：为消息类型，mtext 为字段。 
msgflg：用于控制 msgsnd 的操作，填写非阻塞 IPC_NOWAIT； 
返回值：成功返回 0，失败返回-1.

msgrcv()：接收消息，定义如下： 
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); 
参数含义： 
msqid：IPC 对象对应的 id； 
msgp：消息指针，消息包含类型和字段； 
msgsz: 消息里的字段大小； 
msgtyp：消息里的类型； 
msgflg：位掩码，不止一个。 
返回值：成功返回接收到的字段大小，错误返回-1。 

msgctl()：控制操作，删除消息队列对象等，定义如下： 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
参数含义： 
msqid：IPC 对象对应的 id； 
cmd：对消息队列对象进行的操作， 
    IPC_STAT：将与消息队列关联的 msqid_ds 复制到 buf; 
    IPC_RMID：删除消息队列对象及 msqid_ds。 
    IPC_SET：把 buf 更新到 msqid_ds。 
buf：描述消息队列的结构体 msqid_ds。

共享内存

使用共享内存的步骤： 
1.调用 shmget()创建共享内存段 id， 
2.调用 shmat()将 id 标识的共享内存段加到进程的虚拟地址空间， 
3.访问加入到进程的那部分映射后地址空间，可用 IO 操作读写。

shmget()：创建共享内存段，生成 id， 
#include <sys/ipc.h> 
#include <sys/shm.h> 
int shmget(key_t key, size_t size, int shmflg); 
参数含义： 
    key：通过 ftok()生成的 key 值； 
    size：分配的内存大小； 
    shmflg：权限和控制标志位。 
返回值：成功返回共享内存 id，失败返回-1。 

shmat()：获取共享内存段地址， 
#include <sys/types.h> 
#include <sys/shm.h> 
void *shmat(int shmid, const void *shmaddr, int shmflg); 
函数功能：将 id 标识的共享内存段添加到进程的地址空间。 
参数含义： 
    shmid：共享内存段的 id； 
    shmaddr：指定将共享内存段附加到该地址，通常写 NULL，让内核帮助选择合适的地址。 
    shmflg：权限掩码位。 返回值：返回附加的共享内存段地址。 

shmdt()：将附加的共享内存段从进程空间分离。 
int shmdt(const void *shmaddr); 
参数含义： 
    shmaddr：附加的共享内存段地址。 
返回值：成功返回 0，失败返回-1。

信号量（信号灯） 

System V 信号灯
使用 System V 信号灯的步骤如下： 
1. 使用 semget()创建或打开一个信号灯集。 
2. 使用 semctl()初始化信号灯集。 
3. 使用 semop()操作信号灯值，即进行 P/V 操作。 
    P 操作：申请资源，申清完后信号灯值-1；
    V 操作：释放资源，释放资源后信号灯值+1；
    
semget()：
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/sem.h> 
int semget(key_t key, int nsems, int semflg); 
函数功能：创建新信号灯集或获取一个创建好的信号灯集。 
参数含义： 
    key：通过 ftok()获取的 key 值； 
    nsems：指定信号灯集合中信号灯的数量； 
    semflg：权限掩码，指定 IPC_CREAT 为如果没有则创建该信号灯集，指定 IPC_EXCL 为如果存 在 返 回错误。
返回值：成功返回信号灯集标识符 id，失败返回-1， 

semctl()：初始化信号灯集合 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/sem.h> 
int semctl(int semid, int semnum, int cmd, .../* union semun arg*/); 
参数含义： 
    semid：信号灯集标识符； 
    semnum：要操作的集合中的信号灯编号 
    cmd：执行的操作 SETVAL IPC_RMID arg ：cmd 指定 SETVAL 命令后由此参数向集合中的单个信号量赋值。
    
semop()：在信号量上执行一个或多个操作。 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/sem.h> int semop(int semid, struct sembuf *sops, size_t nsops); 
参数含义： 
    semid：信号灯集标识符； 
    sops：指向数组的指针，数组成员是对信号灯操作的结构体； 
    struct sembuf 
    { 
        unsigned short sem_num; /*信号量索引*/ 
        short sem_op; /* 执行的操作，+1 或-1 */ 
        short sem_flg; /* ，阻塞 0，不阻塞 IPC_NOWAIT */ 
    } 
    nsops：数组大小，最小是 1。 
    返回值：成功返回 0，失败返回-1。
JoYER_cc
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值