linux进程间通信学习

最新推荐文章于 2022-01-12 22:22:07 发布
最新推荐文章于 2022-01-12 22:22:07 发布
阅读量201 收藏 1
点赞数 1
分类专栏： Linux系统 文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33232152/article/details/120286984
版权

linux进程间通信学习

管道通信

匿名管道

匿名管道称为半双工管道，特点如下：

  • 数据只能由一个进程流向另一个进程，如果要进行双工通信，则需要建立两个管道。

  • 管道只能用于父子进程或者兄弟进程间通信。

管道创建函数
#include <unistd.h>

int pipe(int fd[2]);
//fd[0] 读管道 fd[1] 写管道，一般的文件I/O函数都可以用于管道，如close、read、write
父子进程通过管道通信测试例子
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define INPUT 0
#define OUTPUT 1

int main()
{
    int fd[2];//定义管道的两端，fd[0]->读，fd[1]->写
    int read_count;
    pid_t pid;
    char buf[256]={'\0'};

    pipe(fd);//创建管道

    pid=fork(); //fork子进程

    if(pid<0)
    {
        printf("error in fork\n");
        exit(1);
    }
    else if(pid==0) //子进程
    {
        close(fd[INPUT]);
        while(1)
        {
            memset(buf,'\0',sizeof(buf));
            fgets(buf,sizeof(buf),stdin);
            write(fd[OUTPUT],buf,strlen(buf));
            if(strncmp("exit",buf,4)==0)
            {
                break;
            }
        }
        exit(0);
    }
    else //父进程
    {
        close(fd[OUTPUT]);
        while (1)
        {
            read_count=read(fd[INPUT],buf,sizeof(buf));
            buf[read_count]='\0';
            printf("%d bytes of data received from child process: %s\n",read_count,buf);
            if(strncmp("exit",buf,4)==0)
            {
                break;
            }
        }
    }
    return 0;
}

命名管道

命名管道提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。其具有以下特点：

  • 使互不相关的两个进程间实现彼此通信
  • 命名管道通过路径名来指出，并且在文件系统中是可见的，可当作普通文件进行读写操作
  • FIFO严格遵循先进先出规则，对管道及FIFO的读操作总是从开始处返回数据，对它们的写操作则是把数据添加到末尾。
命名管道创建
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname,mode_t mode);
//pathname 普通的路径名
//与open()函数中的mode相同
//创建成功后，一般文件的I/O函数都可以作用于FIFO，如close、read、write等。
命名管道通信测试例子
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define P_FIFO "/tmp/p_fifo" //命名管道的名字

//命名管道读测试
int read_fifo()
{
    char cache[100]={'\0'};
    int fd;

    memset(cache,0,sizeof(cache));

    if(access(P_FIFO,F_OK)==0) //判断管道是否存在，若存在就删除
    {
        execlp("rm","-f",P_FIFO,NULL);
        printf("access.\n");
    }

    if(mkfifo(P_FIFO,0777)<0) //创建命名管道
    {
        printf("create named pipe failed.\n");
    }

    fd=open(P_FIFO,O_RDONLY|O_NONBLOCK);//打开命名管道，以读权限以及非阻塞模式打开
    while(1)
    {
        memset(cache,0,sizeof(cache));
        if((read(fd,cache,100))==0) //读取命名管道里面的数据
        {
            printf("nodata:\n");
        }
        else
        {
            printf("getdata:%s\n",cache);
            if(strncmp("exit",cache,4)==0)
            {
                break;
            }
        }
        sleep(1);
    }
    close(fd);
    return 0;
}

//命名管道写测试
int write_fifo()
{
    int fd;
    char cache[100]={'\0'};
    fd=open(P_FIFO,O_WRONLY|O_NONBLOCK);//打开命名管道，以写权限以及非阻塞模式打开命名管道
    while(1)
    {
        fgets(cache,sizeof(cache),stdin);
        write(fd,cache,sizeof(cache)); //往命名管道写入数据
        if(strncmp("exit",cache,4)==0)
        {
            break;
        }
    }

    close(fd);

    return 0;
}

消息队列

用于同一台机器上的进程间通信，与管道相似，是一个在系统内核中用来保存消息的队列。在系统内核中是以消息链表的形式出现。

相关函数说明

创建新消息队列或取得已存在的消息队列
int msgget(key_t,int msgflg);
//key 可认为是一个端口号，可由ftok函数生成
//msgflg ，若为IPC_CREAT,则如果没有该队列，就创建一个并返回新标识符，如果已经存在就返回原标识符
//msgflg，若为IPC_EXCL,如果没有该队列，则返回-1，若已存在，则返回0
读写消息队列
//从消息队列读取信息
ssize_t msgrcv(int msqid,void *msgp,size_t msgsz,long msgtyp,int msgflg);

//向消息队列发送信息
int msgsnd(int msqid,const void *msgp,size_t msgsz,int msgflg);

//msqid 消息队列标识码
//msgp 指向消息缓冲区的指针，用于暂时存储发送和接收的消息，是一个用户可自定义的通用数据结构，一般定义为结构体
//msgsz 消息的大小
//msgtyp 指从消息队列内读取的消息形态，如果值为零，则表示消息队列中的所有消息都会被读取。
//msgflg 指明核心程序在队列没有数据的情况下所应采取的行动，如果msgflg和常数IPC_NOWAIT合用，则在msgsnd()执行时若是消息队列已满，则msgsnd()将不会阻塞，而立即返回-1，如果执行的是msgrcv(),则在消息队列为空时，不做等待马上返回-1，并设定错误码为ENOMSG,当msgflg为0时，msgsnd()及msgrcv()在队列为满或为空的情形时，采取阻塞等待的处理模式。
设置消息队列属性
int msgctl(int msgqid,int cmd,struct msqid_ds *buf);
//对msgqid标识的消息队列执行cmd操作，系统定义了3种cmd操作：IPC_STAT、IPC_SET、IPC_RMID。
//IPC_STAT 用来获取消息队列对应的msqid_ds数据结构，并将其保存到buf指定的地址空间。
//IPC_SET 用来设置消息队列的属性，要设置的属性存储在buf种
//IPC_RMID 用来从内核种删除msqid标识的消息队列
消息队列通信测试例子
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/msg.h>

struct msg_st{
    long int msg_type;
    char text[512];
};

int msg_receive()
{
    int running = 1;
    int msgid = -1;

    struct msg_st data;
    memset(&data,0,sizeof(data));

    long int msgtype = 0;
    
    //建立消息队列
    msgid = msgget((key_t)1234,0666|IPC_CREAT);
    if(msgid==-1)
    {
        fprintf(stderr,"msgget failed with error:%d\n",errno);
        exit(EXIT_FAILURE);
    }

    while(running)
    {
        //从消息队列种获取信息，遇到exit结束
        if(msgrcv(msgid,(void*)&data,sizeof(data),msgtype,0)==-1)
        {
            fprintf(stderr,"msgrcv failed with error:%d\n",errno);
            exit(EXIT_FAILURE);
        }

        printf("You write: %s\n",data.text);
        if(strncmp("exit",data.text,4)==0)
        {
            running=0;
        }
    }
    //删除消息队列
    if(msgctl(msgid,IPC_RMID,0)==-1)
    {
        fprintf(stderr,"msgctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);

}

int msg_send()
{
    int running=1;
    struct msg_st data;

    char buffer[512];

    int msgid=-1;  
    
    //建立消息队列
    msgid=msgget((key_t)1234,0666|IPC_CREAT);
    if(msgid==-1)
    {
        fprintf(stderr,"msgget failed with error:%d\n",errno);
        exit(EXIT_FAILURE);
    }

    while(running)
    {
        printf("Enter some msg: \n");
        fgets(buffer,512,stdin);
        data.msg_type=1;
        strcpy(data.text,buffer);
        //向消息队列发送数据
        if(msgsnd(msgid,(void*)&data,512,0)==-1)
        {
            fprintf(stderr,"msgsnd() failed\n");
            exit(EXIT_FAILURE);
        }

        if(strncmp("exit",buffer,4)==0)
        {
            running=0;
        }
        sleep(1);
    }
    exit(EXIT_SUCCESS);
}
消息队列与命名管道区别
  • 消息队列可以独立于发送和接收进程而存在，从而消除了在同步命名管道的打开和关闭时可能产生的困难
  • 可以同时通过发送消息以避免命名管道的同步和阻塞问题，而不需要由进程自己来提供同步方法
  • 接收程序可以通过消息类型有选择地接收数据，而不像命名管道，只能默认接收

共享内存

​ 允许两个不相关的进程访问同一个逻辑内存，在两个运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排在同一段的物理内存中，进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址。

​ 共享内存未提供同步机制，通常需要其他的机制来同步对共享内存的访问。

相关函数说明

创建共享内存
#include <sys/shm.h>

int shmget(key_t key,int size,int flag);
//key 非0整数，有效地为共享内存段命名
//size 以字节为单位指定需要共享的内存容量
//flag 权限标志，作用与open函数的mode参数一样，如果要想在key标识的共享内存不存在的条件下创建它的话，可以与IPC_CREAT做或操作。
//shmget函数运行成功时返回一个与key相关的共享内存标志符（非负整数）用于后续的共享内存函数，调用失败时返回-1。
将共享内存连接到自身的地址空间中
void *shmat(int shmid,void *addr,int flag);
//shmid 为shmget函数返回的共享存储标识符
//addr与flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，其他进程可以对此进程进行读写操作。
将共享内存与当前进程分离
int shmdt(const void *shmaddr);
//shmaddr是shmat函数返回的地址指针，调用成功返回0，失败返回-1

共享内存通信测试例子

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

#define TEXT_SZ 2048
struct shared_use_st {
    int written;
    char text[TEXT_SZ];
};

int consumer()
{
    int shmid;
    srand((unsigned int)getpid());//设置随机种子

    //创建共享内存
    shmid=shmget((key_t)1234,sizeof(struct shared_use_st),0666|IPC_CREAT);
    if(shmid==-1)
    {
        fprintf(stderr,"shmget failed\n");
        exit(EXIT_FAILURE);
    }

    void *shared_memory=(void*)0;
    //将共享内存连接到自身的地址空间内
    shared_memory=shmat(shmid,(void*)0,0);
    if(shared_memory==(void*)-1)
    {
        fprintf(stderr,"shmat failed\n");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n",(long)shared_memory);
    struct shared_use_st *shared_stuff;
    shared_stuff=(struct shared_use_st*)shared_memory;
    shared_stuff->written=0;
    int running=1;
    while(running)
    {
        if(shared_stuff->written)//判断是否有数据写入
        {
            printf("You wrote: %s\n",shared_stuff->text);
            sleep(rand()%4);
            shared_stuff->written=0;
            if(strncmp("exit",shared_stuff->text,4)==0)
            {
                running=0;
            }
        }
    }

    //将共享内存与当前进程分离
    if(shmdt(shared_memory)==-1)
    {
        fprintf(stderr,"shmdt failed\n");
        exit(EXIT_FAILURE);
    }

    //删除共享内存
    if(shmctl(shmid,IPC_RMID,0)==-1)
    {
        fprintf(stderr,"shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

int producer()
{
    int shmid;
    //获取共享内存
    shmid=shmget((key_t)1234,sizeof(struct shared_use_st),0666|IPC_CREAT);
    if(shmid==-1)
    {
        fprintf(stderr,"shmget failed\n");
        exit(EXIT_FAILURE);
    }

    void *shared_memory=(void*)0;

    //将共享内存连接到当前进程的地址空间中
    shared_memory=shmat(shmid,(void*)0,0);
    if(shared_memory==(void*)-1)
    {
        fprintf(stderr,"shmat failed\n");
        exit(EXIT_FAILURE);
    }

    printf("memory attached at %X\n",(long)shared_memory);
    struct shared_use_st *shared_stuff;
    shared_stuff=(struct shared_use_st*)shared_memory;
    int running=1;
    char buffer[TEXT_SZ];
    while(running)
    {
        while(shared_stuff->written==1)
        {
            sleep(1);
            printf("waiting for client...\n");
        }

        printf("Enter some text: ");
        fgets(buffer,TEXT_SZ,stdin);
        strncpy(shared_stuff->text,buffer,TEXT_SZ); //往共享内存写入数据
        shared_stuff->written=1;
        if(strncmp("exit",buffer,4)==0)
        {
            running=0;
        }
    }

    //将共享内存与当前进程分离
    if(shmdt(shared_memory)==-1)
    {
        fprintf(stderr,"shmdt failed\n");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

信号量

用于用户态进程通信的SYSTEM V信号量，信号量用来协调进程对共享资源的访问，

信号量只能进行等待和发送信号。即P和V操作。

  • P(sv)操作，如果sv大于0，就减1，如果sv为0，就挂起该进程的执行
  • V(sv)操作，如果有其他进程因等待而被挂起，就让它恢复运行，如果没有进程因等待而挂起，就给它加1

相关函数说明

创建和打开信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key,int nsems,int semflg);
//成功返回信号量标识符，失败返回-1
//key，通过ftok函数得到的键值
//nsems 代表创建信号量的个数，如果只是访问而不创建可以指定该参数为0，但一旦创建了信号量，就不能更改其信号量个数
//semflg 指定该信号量的读写权限
改变信号量的值
int semop(int semid,struct sembuf *sops,unsigned nsops);
//semid 由semget返回的信号量标识符
//sembuf结构体
/*
struct sembuf{
	short sem_num;//除非使用一组信号量，否则为0
    short sem_op;//信号量在一次操作中需改变的数据，通常是两个数：-1 P操作，1 V操作
    short sem_flg;//通常为SEM_UNDO，使操作系统跟踪信号，在进程没有释放该信号量而终止时，操作系统释放信号量
}
*/
直接控制信号量信息
int semctl(int semid,int semnum,int cmd, ...);
//成功返回一个整数，失败返回-1
/*
如果有第四个参数，通常是一个union semum结构，定义如下：
union semun {
	int val;
	struct semid_ds *buf;
	unsigned short *arry;
	struct seminfo *__buf;
};

cmd:
IPC_SET：对此集合去semid_ds结构，并存放在由arg.buf指向的结构中
SETVAL：设置信号量集中的一个单独的信号量的值，此时需要传入第四个参数
IPC_RMID:从系统中删除该信号量
*/

信号量通信测试例子

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

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

#define SEM_KEY 4001
#define SHM_KEY 5678

union semun {
    int val;
};

int sem_read()
{
    int semid,shmid;

    //创建共享内存
    shmid=shmget(SHM_KEY,sizeof(int),IPC_CREAT|0666);
    if(shmid<0)
    {
        printf("create shm error\n");
        return -1;
    }

    void *shmptr;
    //将共享内存连接到当前进程地址空间内
    shmptr=shmat(shmid,NULL,0);
    if(shmptr==(void*)-1)
    {
        printf("shmat error:%s\n",strerror(errno));
        return -1;
    }

    int *data=(int*)shmptr;
    //创建信号量，个数为2
    semid=semget(SEM_KEY,2,IPC_CREAT|0666);
    union semun semun1;
    semun1.val=0;
    //设置信号量值
    semctl(semid,0,SETVAL,semun1);

    semun1.val=1;
    //设置信号量值
    semctl(semid,1,SETVAL,semun1);

    struct sembuf sembuf1;
    while(1)
    {
        sembuf1.sem_num=0;
        sembuf1.sem_op=-1;//等待操作
        sembuf1.sem_flg=SEM_UNDO; //使操作系统跟踪信号
        semop(semid,&sembuf1,1);
        printf("the NUM:%d\n",*data);

        sembuf1.sem_num=1;
        sembuf1.sem_op=1; //发送操作
        sembuf1.sem_flg=SEM_UNDO;
        semop(semid,&sembuf1,1);

        if((*data)==-1)
        {
            break;
        }
    }

    //将共享内存与当前进程分离
    if(shmdt(shmptr)==-1)
    {
        fprintf(stderr,"shmdt failed\n");
        exit(EXIT_FAILURE);
    }

    //删除共享内存
    if(shmctl(shmid,IPC_RMID,0)==-1)
    {
        fprintf(stderr,"shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }

    return 0;
}

int sem_write()
{
    int semid,shmid;
    //获取共享内存
    shmid=shmget(SHM_KEY,sizeof(int),IPC_CREAT|0666);
    if(shmid<0)
    {
        printf("create shm error\n");
        return -1;
    }

    void *shmptr;
    //将共享内存连接到当前进程地址空间内
    shmptr=shmat(shmid,NULL,0);
    if(shmptr==(void*)-1)
    {
        printf("shmat error:%s\n",strerror(errno));
        return -1;
    }

    int *data=(int*)shmptr;
    //获取信号量，个数为2
    semid=semget(SEM_KEY,2,0666);
    struct sembuf sembuf1;
    union semun semun1;
    while(1)
    {
        sembuf1.sem_num=1;
        sembuf1.sem_op=-1;//等待操作
        sembuf1.sem_flg=SEM_UNDO;
        semop(semid,&sembuf1,1);
        scanf("%d",data);

        sembuf1.sem_num=0;
        sembuf1.sem_op=1;//发送操作
        sembuf1.sem_flg=SEM_UNDO;
        semop(semid,&sembuf1,1);

        if((*data)==-1)
        {
            break;
        }
    }

    return 0;
}

套接字

UNIX本地套接字，是在socket的框架上发展出的一种IPC机制，即UNIX Domain Socket。用于同一台计算机上运行的进程之间的通信。它的执行效率更高，不需要进行协议处理，仅仅是复制数据，将应用数据从一个进程拷贝到另一个进程。

UNIX本地套接字也提供面向流和面向消息的两种API接口，类似于TCP和UDP，但是面向消息的UNIX本地套接字也是可靠的，即消息不会丢失也不会顺序错乱。

相关函数说明

创建套接字
int socket(int domain,int type,int protocol);
//domain 协议族，对于本地套接字，为AF_LOCAL 或 AF_UNIX
//type：确定套接字类型 SOCKET_STREAM(面向流) SOCKET_SEQPACKET（面向消息）
//protocol：默认传0 默认协议即可
本地套接字地址结构
struct sockaddr_un {
    __kernel_sa_family_t sun_family;//地址结构类型
    char sun_path[UNIX_PATH_MAX]; //socket文件名（含路径） 绝对路径
}
绑定套接字
int unlink(char *pathname);
int remove(char *pathname);
int bind(int socket,const struct sockaddr  *address,size_t address_len);
//struct sockaddr: 本地套接字地址结构，使用struct sockaddr_un
监听
int listen(int socket,int backlog);
int accept(int socket,struct sockaddr *address,size_t *address_len);
//struct sockaddr: 本地套接字地址结构，使用struct sockaddr_un
连接
int connect(int socket,const struct sockaddr *address,size_t address_len);
//struct sockaddr: 本地套接字地址结构，使用struct sockaddr_un
读写
ssize_t read(int fd,void *buf,size_t count);
sszie_t write(int fd,const void *buf,size_t count);
通信流程
服务端：
  1. 创建本地套接字
  2. 绑定本地套接字
  3. 监听
  4. 消息收发
客户端：
  1. 创建本地套接字
  2. 绑定本地套接字
  3. 链接
  4. 消息收发

套接字通信测试例子

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <errno.h>

#define UNIX_STREAM_PATH "/tmp/unix_socket.socket"
#define BUFFER_SIZE 4096

int unix_socket_server()
{
    int listen_fd,con_fd;
    int index=0,read_len=0;
    socklen_t len;
    struct sockaddr_un servaddr,cliaddr;
    char buf[BUFFER_SIZE];

    if((listen_fd=socket(AF_LOCAL,SOCK_STREAM,0))==-1)
    {
        fprintf(stderr,"socket(AF_LOCAL) error:%s\n",strerror(errno));
        exit(EXIT_FAILURE);
    }

    unlink(UNIX_STREAM_PATH);

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sun_family=AF_LOCAL;
    strcpy(servaddr.sun_path,UNIX_STREAM_PATH);

    if(bind(listen_fd,(struct sockaddr*)&servaddr,sizeof(servaddr))==-1)
    {
        fprintf(stderr,"bind(AF_LOCAL) error:%s\n",strerror(errno));
        exit(EXIT_FAILURE);
    }

    listen(listen_fd,20);

    printf("begin Accept ...\n");

    len=sizeof(cliaddr);

    if((con_fd=accept(listen_fd,(struct sockaddr*)&cliaddr,&len))==-1)
    {
        fprintf(stderr,"accept(AF_LOCAL) error:%s\n",strerror(errno));
        exit(EXIT_FAILURE);
    }

    while(1)
    {
        bzero(buf,sizeof(buf));
        if((read_len=read(con_fd,buf,sizeof(buf)))==0)
        {
            break;
        }
        printf("recv:%s\n",buf);
        for(index=0;index<read_len;index++)
        {
            buf[index]=toupper(buf[index]);
        }
        write(con_fd,buf,read_len);

        if(strncmp("exit",buf,4)==0)
        {
            break;
        }
    }
    close(con_fd);
    close(listen_fd);

    return 0;
}

int unix_socket_client()
{
    int con_fd;
    int read_len=0;
    struct sockaddr_un servaddr;
    char buf[BUFFER_SIZE];

    con_fd=socket(AF_LOCAL,SOCK_STREAM,0);

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sun_family=AF_LOCAL;
    strcpy(servaddr.sun_path,UNIX_STREAM_PATH);

    connect(con_fd,(struct sockaddr*)&servaddr,sizeof(servaddr));

    while(1)
    {
        bzero(buf,sizeof(buf));
        printf("Enter text: \n");
        if(fgets(buf,sizeof(buf),stdin)==NULL)
        {
            break;
        }
        write(con_fd,buf,strlen(buf));
        read_len=read(con_fd,buf,sizeof(buf));
        printf("recv:%s\n",buf);
        if(strncmp("EXIT",buf,4)==0)
        {
            break;
        }
    }

    close(con_fd);

    return 0;
}
skynetkang
关注
专栏目录
skynet中cluster和harbor，进程间通信方式的分析与对比
HERO_1的专栏
08-09 1036
skynet
C Primer Plus 第十三章 课后答案
asdgyy的博客
10-06 5889
目录   复习题 1.下面的程序有什么问题 2.下面的程序完成什么任务？（假设在命令行环境中运行） 3.假设程序中有下列语句： 另外，假设成功打开了两个文件。补全下面函数调用中缺少的参数： a.ch = getc(); b.fprintf( ,"%c\n", ); c.putc( , ); d.fclose(); /* 关闭terky文件 */ 4.编写一个程序，不接受任何命...
进程之间的通信
qq_43257899的博客
11-23 105
#include &lt;sys/types.h&gt; #include &lt;sys/ipc.h&gt; #include &lt;sys/msg.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;sys/types.h&gt; #include &lt;unistd.h&gt; #define MS
skynet通信模式的思考与扩展
12-27 158
skynet提供服务的方式是基于harbor间通信来完成，在skynet的配置文件中有一个harbor参数，这个参数我原来以为是用来控制一个master集群可以启动多少个harbor结点的，一次写demo的过程中，发现skynet.send无法调用另一个harbor的服务，总是报告drop message，检查之后才发现是因为它们在config配置里，属于同一个harbor，才明白这个参...
LinuxC应用开发学习笔记（十四）—管道算法和进程间通信
梅山
01-12 454
管道算法和进程间通信 管道的实现 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #define BUFSIZE 1024 int main() { int pd[2],len = 0; __pid_t pid; char buf[BUFSIZE]; if(pipe(pd)<0) {
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
Linux进程间通信测试程序.zip_linux_linux 程序_linux 网络_linux网络_进程间通信
09-24
压缩包中的"www.pudn.com.txt"可能包含了关于这个测试程序的更多说明或者参考资源，而"Linux进程间通信测试程序"可能是实现这些通信方式的一个实例代码库。通过分析和运行这个程序，你可以了解每种通信方式的具体...
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
在Linux操作系统中，进程间通信（IPC，Inter-...通过阅读“pipe.c”中的代码，理解“Linux管道学习.doc”的理论知识，并参考“showart_1225848.html”中的案例，可以全面地学习和掌握Linux进程间通信的核心技术。
Linux Socket编程、Linux IO模型、Linux 进程间通信完整用例
最新发布
02-16
最后，我们来谈谈**Linux进程间通信**。在多进程环境中，进程间通信（IPC）用于实现不同进程间的数据交换和协调。Linux提供了多种IPC机制，包括管道（pipe）、消息队列（message queue）、共享内存（shared memory）...
Linux进程间通信之共享内存
07-26
Linux进程间通信的共享内存是一种高效的数据交换方式，但是对共享内存的访问同步控制需要程序员自己实现，这是在使用共享内存时需要注意的问题。通过上述步骤和示例程序的学习，我们可以更好地理解共享内存的工作...
Linux文件服务站（C语言）
知足且坚定，温柔且上进
02-05 596
服务端代码： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h
学习C语言——学习笔记（1）
wzwpy99的博客
01-12 1237
1.预处理指令 预处理指令解释为由预处理器读入源码，然后根据预处理指令对其进行修改，最后将修改过后的源代码递交给编译器 以下5行都是预处理指令： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_COLS 20 #define MAX_INPUT 1000 预处理指令的作用仿佛是将stdio.h的内容逐字写到源文件的位置，以上第二、三条指令的功能都类似，不同点在于二、三条替换
Linux信号的使用和进程间通信
qq_41721746的博客
10-23 685
一、信号的使用 1. 信号的基本概念 2. 修改信号的响应方式---signal() 3. 发送信号---kill() 二、 进程间通信（IPC） 1. 管道 2. 信号量 3. 共享内存 4. 消息队列
linux系统编程之管道(一)
webor2006的博客
10-22 447
今天继续研究linux系统编程，继上次对信号进行研究之后，这次开始一个新的章节-----管道，在正式开始之前，先把今天让自己很激动的事说一下，小小的兴奋，经过下周后自己的创业产品用户量就有一个质的飞越了，百万级的，虽说离最终的目标还有很远，但是，这说明自己团队最近几个月的辛苦付出是值得的，也让自己对这次的创业更加有期待了，小小骄傲一下，我的学习任务还得继续坚持，谁叫咱是搞技术的呢，言归正传，正入正题： 什么是管道: 实际上，我们在linux中经常会用到带"管道"的命令,如： 那管道的本
Linux管道操作的理解和代码实证
BigTiger_world的博客
09-28 343
要理解管道操作，必须知道Linux的文件和文件描述符概念。 关于这两个概念的理解，在我的两个浅文《Linux文件描述符、重定向》和《Linux Shell脚本攻略一书中－关于重定向理解与补充》都有提及。虽然不想啰嗦，但为了文意连贯，有助于理解，还不得不再提一下要点。 1 关于Linux文件和文件描述符 简单提一下几个要点： （１）在Linux中，一切都是文件。屏幕是文件，键盘是文件，系统错误也被抽象成了一个文件。当然，各种磁盘文件、各种设备，都是文件。 （２）是文件都有其对应的名字...
linux进程通信之管道-含代码例子
码呀码代码
10-10 980
目录   分类 功能区别 无名管道 命名管道 分类 1、无名管道 2、命名管道 功能区别 无名管道只能用于有父子关系的进程之间，通过公用进程描述符来实现连接在同一个管道。 命名管道可以实现任意两个进程之间的通信。 无名管道 （此图从别处盗用过来的） 从这个图中可以看出来： 1、父进程首先创建了一个管道，管道的连个文件描述符分别保存在fd[0],fd[1]中，这两个...
Linux操作系统实验系列之实验四管道通信
weixin_43372169的博客
12-03 3296
一、实验目的 1、了解什么是管道 2、熟悉UNIX/LINUX支持的管道通信方式 二、实验内容： 编写程序实现进程的管道通信。用系统调用pipe( )建立一管道，二个子进程P1和P2分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 父进程从管道中读出二个来自子进程的信息并显示。 三、实验环境 Linux操作系统 四、实验过程与运行结果 源代码： #include<unistd.h> #include&l
Linux之进程（二）进程间通信
hello
02-25 507
进程间通信（IPC，InterProcess Communication） 参考博客：https://blog.csdn.net/tangtang_yue/article/details/78296620? 是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 一、管道（无名管道） 相当于水管，从上端流入，下端流出，内容被读取后管道就是空...
进程间通信：信号
qq_41962968的博客
08-21 268
对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。 信号概述 信号的名字和编号： 每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。 信号定义在signal.h头文件中，信号名都定义为正整数。 具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。ki
Linux进程间通信详解-孙天泽
"这篇资料是孙天泽在华清远见分享的关于Linux进程间通信的讲解，涵盖了嵌入式Linux应用程序开发、Linux进程以及进程间通信等主题。内容包括Linux内核结构、进程与程序的区别、进程的特点、进程的组成以及进程控制块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值