LInux--进程间通信

最新推荐文章于 2023-03-07 18:32:14 发布

hhhhhh!

最新推荐文章于 2023-03-07 18:32:14 发布

阅读量246

点赞数 2

本文链接：https://blog.csdn.net/qq_42579119/article/details/86514060

版权

1.进程间通信概念介绍：
1.1（1）.数据传输
一个进程需要将它的数据发送给另一个进程
（2).资源共享
多个进程之间共享同样的资源
(3)通知事件
一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件
(4).进程控制
有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变
1.2Linux进程间通信（IPC）由以下几部分发展而来：
1.UNIX进程间通信
2.基于System V进程间通信
3.POSIX进程间通信
2.进程间通信方式
2.1共享内存
进程间需要共享的数据被放在一个叫做IPC共享内存区域的地方，所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。系统V共享内存通过shmget获得或创建一个IPC共享内存区域，并返回相应的标识符。内核在保证shmget获得或创建一个共享内存区，初始化该共享内存区相应的shmid_kernel结构注同时，还将在特殊文件系统shm中，创建并打开一个同名文件，并在内存中建立起该文件的相应dentry及inode结构，新打开的文件不属于任何一个进程（任何进程都可以访问该共享内存区）。所有这一切都是系统调用shmget完成的。
2.1.1共享内存实现分为两个步骤:
一、创建共享内存，使用shmget函数
二、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数
2.1.2 int shmget ( key_t key, int size, int shmflg )

 key标识共享内存的键值: 0/IPC_PRIVATE。 当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。

 返回值：如果成功，返回共享内存标识符；如果失败，返回-1

2.1.3char * shmat ( int shmid, char *shmaddr, int flag)
参数：
shmid：shmget函数返回的共享存储标识符
flag：决定以什么方式来确定映射的地址（通常为0）
返回值：
如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回- 1
2.1.4当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。
int shmdt ( char *shmaddr )
2.1.5
#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <error.h>

#define SIZE 1024

int main()

{

int shmid ;

char *shmaddr ;

struct shmid_ds buf ;

int flag = 0 ;

int pid ;



shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT|0600 ) ;

if ( shmid < 0 )

{

        perror("get shm  ipc_id error") ;

        return -1 ;

}

pid = fork() ;

if ( pid == 0 )

{

    shmaddr = (char *)shmat( shmid, NULL, 0 ) ;

    if ( (int)shmaddr == -1 )

    {

        perror("shmat addr error") ;

        return -1 ;



    }

    strcpy( shmaddr, "Hi, I am child process!\n") ;

    shmdt( shmaddr ) ;

    return  0;

} else if ( pid > 0) {

    sleep(3 ) ;

    flag = shmctl( shmid, IPC_STAT, &buf) ;

    if ( flag == -1 )

    {

        perror("shmctl shm error") ;

        return -1 ;

    }



    printf("shm_segsz =%d bytes\n", buf.shm_segsz ) ;

    printf("parent pid=%d, shm_cpid = %d \n", getpid(), buf.shm_cpid ) ;

    printf("chlid pid=%d, shm_lpid = %d \n",pid , buf.shm_lpid ) ;

    shmaddr = (char *) shmat(shmid, NULL, 0 ) ;

    if ( (int)shmaddr == -1 )

    {

        perror("shmat addr error") ;

        return -1 ;



    }

    printf("%s", shmaddr) ;

    shmdt( shmaddr ) ;

    shmctl(shmid, IPC_RMID, NULL) ;

}else{

    perror("fork error") ;

    shmctl(shmid, IPC_RMID, NULL) ;

}



return 0 ;

}

编译 gcc shm.c –o shm。

执行 ./shm，执行结果如下：

shm_segsz =1024 bytes

shm_cpid = 9503

shm_lpid = 9504

Hi, I am child process!

多进程读写范例
多进程读写即一个进程写共享内存，一个或多个进程读共享内存。下面的例子实现的是一个进程写共享内存，一个进程读共享内存。

（1）下面程序实现了创建共享内存，并写入消息。

shmwrite.c源代码如下：

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <sys/types.h>

#include <unistd.h>

#include <string.h>

typedef struct{

char name[8];

int age;

} people;

int main(int argc, char** argv)

{

int shm_id,i;

key_t key;

char temp[8];

people *p_map;

char pathname[30] ;



strcpy(pathname,"/tmp") ;

key = ftok(pathname,0x03);

if(key==-1)

{

    perror("ftok error");

    return -1;

}

printf("key=%d\n",key) ;

shm_id=shmget(key,4096,IPC_CREAT|IPC_EXCL|0600); 

if(shm_id==-1)

{

    perror("shmget error");

    return -1;

}

printf("shm_id=%d\n", shm_id) ;

p_map=(people*)shmat(shm_id,NULL,0);

memset(temp, 0x00, sizeof(temp)) ;

strcpy(temp,"test") ;

temp[4]='0';

for(i = 0;i<3;i++)

{

    temp[4]+=1;

    strncpy((p_map+i)->name,temp,5);

    (p_map+i)->age=0+i;

}

shmdt(p_map) ;

return 0 ;

}

（2）下面程序实现从共享内存读消息。

shmread.c源代码如下：

#include <stdio.h>

#include <string.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <sys/types.h>

#include <unistd.h>

typedef struct{

char name[8];

int age;

} people;

int main(int argc, char** argv)

{

int shm_id,i;

key_t key;

people *p_map;

char pathname[30] ;



strcpy(pathname,"/tmp") ;

key = ftok(pathname,0x03);

if(key == -1)

{

    perror("ftok error");

    return -1;

}

printf("key=%d\n", key) ;

shm_id = shmget(key,0, 0);   

if(shm_id == -1)

{

    perror("shmget error");

    return -1;

}

printf("shm_id=%d\n", shm_id) ;

p_map = (people*)shmat(shm_id,NULL,0);

for(i = 0;i<3;i++)

{

    printf( "name:%s\n",(*(p_map+i)).name );

    printf( "age %d\n",(*(p_map+i)).age );

}

if(shmdt(p_map) == -1)

{

    perror("detach error");

    return -1;

}

return 0 ;

}

（3）编译与执行

① 编译gcc shmwrite.c -o shmwrite。

② 执行./shmwrite，执行结果如下：

key=50453281

shm_id=688137

③ 编译gcc shmread.c -o shmread。

④ 执行./shmread，执行结果如下：

key=50453281

shm_id=688137

name:test1

age 0

name:test2

age 1

name:test3

age 2

⑤ 再执行./shmwrite，执行结果如下：

key=50453281

shmget error: File exists
可用 ipcrm -m 共享内存标识符大小即可。
2.2管道通信
2.2.1管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。
一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据
2.2.2管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。
无名管道创建：
int pipe(int filedis[2])；
当一个管道建立时，它会创建两个文件描述符：
filedis[0] 用于读管道，
filedis[1] 用于写管道
2.2.3管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道
!!!注意：必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符
2.3 消息队列：
消息队列就是一个消息的链表.可以把消息看作一个记录，具有特定的格式.进程可以向中按照一定的规则添加新消息;另一些进程则可以从消息队列中读走消息
2.3.1msgget:
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg)

key：键值，由ftok获得。
msgflg：标志位。
返回值：与健值key相对应的消息队列描述字

msgflag:
IPC_CREAT
创建新的消息队列
IPC_EXCL
与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
IPC_NOWAIT
读写消息队列要求无法得到满足时，不阻塞

Msqid: 已打开的消息队列id
Msgp: 存放消息的结构
Msgsz: 消息数据长度
Msgflg:
发送标志，有意义的msgflg标志为IPC_NOWAIT，指明在消息队列没有足够空间容纳要发送的消息时，msgsnd是否等待

2.3.2 接收消息 msgrcv
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg)

功能：
从msqid代表的消息队列中读取一个msgtyp类型的消息，并把消息存储在msgp指向的msgbuf结构中。在成功地读取了一条消息以后，队列中的这条消息将被删除
struct msgbuf
{
long mtype；/消息类型/
char mtext[1]; /消息数据的首地址/
}
2.4 信号量
2.4.1信号灯的含义介绍：
信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源.
进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步
2.4.2信号灯的分类:
二值信号灯：信号灯的值只能取0或1，类似于互斥锁。但两者有不同：
信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；
互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。
计数信号灯：信号灯的值可以取任意非负值
2.4.3
信号量的操作——semop函数
信号量的值与相应资源的使用情况有关，当它的值大于 0 时，表示当前可用的资源数的数量；当它的值小于 0 时，其绝对值表示等待使用该资源的进程个数。信号量的值仅能由 PV 操作来改变。

 在 Linux 下，PV 操作通过调用semop函数来实现。该函数定义在头文件 sys/sem.h中，原型如下：
 int  semop（int  semid，struct sembuf  *sops，size_t nsops）；
 函数的参数 semid 为信号量集的标识符；参数 sops 指向进行操作的结构体数组的首地址；参数 nsops 指出将要进行操作的信号的个数。semop 函数调用成功返回 0，失败返回 -1。
 semop 的第二个参数 sops 指向的结构体数组中，每个 sembuf 结构体对应一个特定信号的操作。因此对信号量进行操作必须熟悉该数据结构，该结构定义在 linux/sem.h，如下所示：
 struct  sembuf{
     unsigned short   sem_num;      //信号在信号集中的索引，0代表第一个信号，1代表第二个信号  
     short            sem_op;      //操作类型
     short            sem_flg;    //操作标志
 };
下面详细介绍一下 sembuf 的几个参数：

sem_op 参数：
sem_op > 0 信号加上 sem_op 的值，表示进程释放控制的资源；

                sem_op = 0          如果没有设置 IPC_NOWAIT，则调用进程进入睡眠状态，直到信号                                         量的值为0；否则进程不回睡眠，直接返回 EAGAIN

                sem_op < 0          信号加上 sem_op 的值。若没有设置 IPC_NOWAIT ，则调用进程阻
                                    塞，直到资源可用；否则进程直接返回EAGAIN

sem_flg 参数：
该参数可设置为 IPC_NOWAIT 或 SEM_UNDO 两种状态。只有将 sem_flg 指定为 SEM_UNDO 标志后，semadj （所指定信号量针对调用进程的调整值）才会更新。此外，如果此操作指定SEM_UNDO，系统更新过程中会撤消此信号灯的计数（semadj）。此操作可以随时进行—它永远不会强制等待的过程。调用进程必须有改变信号量集的权限。

     sem_flg公认的标志是 IPC_NOWAIT 和 SEM_UNDO。如果操作指定SEM_UNDO，它将会自动撤消该进程终止时。
    在标准操作程序中的操作是在数组的顺序执行、原子的，那就是，该操作要么作为一个完整的单元，要么不。如果不是所有操作都可以立即执行的系统调用的行为取决于在个人sem_flg领域的IPC_NOWAIT标志的存在。
        对信号量最基本的操作就是进行PV操作，而System V信号量正是通过 semop 函数和 sembuf 结构体的数据结构来进行PV操作的。
    当 sembuf 的第二个数据结构 sem_op 设置为负数时，是对它进行P操作，即减1操作；当设置为正数时，就是进行V操作，即加1操作。

重点介绍的是semop函数。该函数主要功能是对信号灯进行P/V操作。

P操作责把当前进程由运行状态转换为阻塞状态，直到另外一个进程唤醒它。操作为：申请一个空闲资源（把信号量减1），若成功，则退出；若失败，则该进程被阻塞；

V操作负责把一个被阻塞的进程唤醒，它有一个参数表，存放着等待被唤醒的进程信息。操作为：释放一个被占用的资源（把信号量加1），如果发现有被阻塞的进程，则选择一个唤醒之。

semop函数原型如下：

int semop(int semid, struct sembuf *sops, unsigned nsops);

semop操作中：sembuf结构的sem_flg成员可以为0、IPC_NOWAIT、SEM_UNDO 。为SEM_UNDO时，它将使操作系统跟踪当前进程对这个信号量的修改情况，如果这个进程在没有释放该信号量的情况下终止，操作系统将自动释放该进程持有的。

sembuf结构的sem_flg成员为SEM_UNDO时，它将使操作系统跟踪当前进程对这个信号量的修改情况，如果这个进程在没有释放该信号量的情况下终止，操作系统将自动释放该进程持有的信号量

问题描述：假设父子进程对一个文件进行写操作，但是这个文件同一时间只能有一个进程进行写操作。

示例程序如下：

#include <stdio.h>
//……此处省略了头文件
void P(int sid)
{
struct sembuf sem_p;
sem_p.sem_num = 0;
sem_p.sem_op = -1;
sem_p.sem_flg = 0;

        if (semop(sid, &sem_p, 1) == -1)
        {
            perror("p op failed");
            exit(1);
        }
    }

    void V(int sid)
    {
        struct sembuf sem_p;
        sem_p.sem_num = 0;
        sem_p.sem_op = 1;
        //sem_p.sem_flg = SEM_UNDO;
        sem_p.sem_flg = 0;

        if (semop(sid, &sem_p, 1) == -1)
        {
            perror("v op failed");
            exit(1);
        }
    }

    int main(int argc, char * argv[ ])
    {
        pid_t pid;
        int fd;
        key_t key;
        int sid;

        if ((fd = open("semset", O_RDWR | O_CREAT, 0666)) == -1)
        {
            perror("open");
            exit( -1);
        }

        if ((key=ftok("semset", 'a')) == -1)
        {
            perror("ftok");
            return -1;
        }

        if ((sid = semget(key, 1, IPC_CREAT | 0666)) == -1)
        {
            perror("createSemset");
            exit(-1);
        }

        if( -1==semctl(sid, 0, SETVAL, 1) )
        {
            perror("SETVAL");
            exit(1);
        }

        if ((pid=fork()) == -1)
        {
            perror("fork");
            exit(-1);
        }
        else if ( 0 == pid )
        {
            while(1)
            {
                P(sid); 
                printf("child writing\n");
                sleep(1);
                printf("child finish post\n");

                V(sid);
            }
        }
        else
        {
            while(1)
            {
                P(sid);
                printf("parent writing");

                sleep(1);
                printf("parent writing finish post\n");

                V(sid);
            }
        }

        return 0;
    }

在该程序中，父子进程都有可能执行P操作成功，因此，两个进程中的提示语句，交替显示。若通过kill命令把其中一个进程杀死，且该进程还没有执行V操作释放资源。若使用SEM_UNDO标志，则操作系统将自动释放该进程持有的信号量，从而使得另外一个进程可以继续工作。若没有这个标志，另外进程将P操作永远阻塞。

因此，一般建议使用SEM_UNDo标志。

hhhhhh!

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
LInux--进程间通信

1.进程间通信概念介绍：1.1（1）.数据传输一个进程需要将它的数据发送给另一个进程（2).资源共享多个进程之间共享同样的资源(3)通知事件一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件(4).进程控制有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变1.2Linux进程间通信（IPC...
复制链接

扫一扫