Fork me on GitHub

进程通信

发表于 | 分类于 ， | | 阅读次数: |
字数统计: 4.2k | 阅读时长 ≈ 19

对进程通信的理解

进程是资源分配的基本单位，所以说某块资源分配给一个进程后，该资源只能是该进程独占，所以进程之间的通信就会比较麻烦，因为需要让不同的进程间能够看到一份公共的资源。所以交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。

实现进程通信的方式

匿名管道（pipe）
  • 管道是通过调用 pipe 函数创建的，是在内核中开辟出的一块缓冲区，fd[0] 用于读，fd[1] 用于写。
  • 只支持半双工通信（单向交替传输）；
  • 只能在父子进程中使用。
  • 父进程关闭读端（fd[0]）,子进程关闭写端(fd[1])，则此时父进程可以往管道中进行写操作，子进程可以从管道中读，从而实现了通过管道的进程间通信
    在这里插入图片描述
示例代码

​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include<stdio.h>
#include<unistd.h>
#include<string.h>
int main(){
	int fd[2];
	int ret = pipe(fd);		//开启匿名管道
	if(ret<0) 
		perror("pipe\n");	//开启失败
	
	pid_t id = fork();		//创建子进程
	if(id<0) 
		perror("fork\n");	//创建失败
	else if(id==0){
		//子进程
		close(fd[0]);		//子进程关闭读端
		int i=0;
		char *mesg = NULL;
		while(i<100){
			mesg = "child";
			write(fd[1], mesg, strlen(mesg)+1);		//向管道另一端写数据
			sleep(1);
			i++;
		}
	}
	else{
		//父进程
		close(fd[1]);		//父进程关闭写端
		int i=0;
		char mesg[100];
		while(i<100){
			memset(mesg, '\0', sizeof(mesg));
			read(fd[0], mesg, sizeof(mesg));		//从管道另一端读数据
			printf("%s\n", mesg);
			j++;
		}
	}
	
	return 0;
}

​

命名管道（FIFO）
  • 命名管道，去除了管道只能在父子进程中使用的限制。
  • 命名管道创建后就可以使用了，使用方法和匿名管道基本相同。只是使用命名管道时，必须先调用open()将其打开，因为命名管道是一个存在于硬盘的文件，而匿名管道是存在于内存中的特殊文件
  • 调用open()打开命名管道的进程可能会被阻塞。但如果同时用读写方式（ O_RDWR）打开，则一定不会导致阻塞；如果以只读方式（ O_RDONLY）打开，则调用open()函数的进程将会被阻塞直到有写方打开管道；同样以写方式（ O_WRONLY）打开也会阻塞直到有读方式打开管道。
    在这里插入图片描述
示例代码

  • 😜Client.c文件，向管道写数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    #include<stdio.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<string.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #define _PATH_NAME_ "/tmp/file.tmp"
    #define _SIZE_ 100
        
    int main(){
    	int ret=mkfifo(_PATH_NAME_,S_IFIFO|0666);		//第一个参数是命名管道存储路径，第二个是命名管道的存取权限
    	if(ret==-1){
    		printf("make fifo error\n");
    		return 1;
    	}
    	
    	char buf[_SIZE_];
    	memset(buf,'\0',sizeof(buf));
    	int fd=open(_PATH_NAME_,O_WRONLY);		//打开命名管道，因为其是硬盘上的文件
    	while(1)
    	{
    		//scanf("%s",buf);
    		fgets(buf,sizeof(buf)-1,stdin);
    		int ret=write(fd,buf,strlen(buf)+1);
    		if(ret<0){
    			printf("write error");
    			break;
    		}
    	}
    	close(fd);
    	return 0;
    }

  • 😜Server.c文件，从管道读数据并输出 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    #include<stdio.h>
    #include<sys/stat.h>
    #include<unistd.h>
    #include<fcntl.h>
    #include<sys/types.h>
    #include<string.h>
    #define _PATH_NAME "/tmp/file.tmp"
    #define _SIZE_ 100
    int main(){
        int fd=open(_PATH_NAME,O_RDONLY);
        if(fd<0){
    		printf("open file error");
            return 1;
        }
    	char buf[_SIZE_];
    	memset(buf,'\0',sizeof(buf));
    	while(1){
    		int ret=read(fd,buf,sizeof(buf));
    		if(ret<0){
    			printf("read end or error\n");
    			break;
    		}
    		printf("%s",buf);
    	}
    	close(fd);
    	return 0;
    }
消息队列

  • 消息队列可以独立于读写进程存在，从而避免了FIFO中为了同步管道的打开和关闭可能产生的困难；

  • 避免了FIFO的同步阻塞问题，不需要进程自己提供同步方法；

  • 读进程可以根据消息类型有选择地接收消息，而不像FIFO那样只能默认地接收. 

    1

    int msgget(key_t key, int msgflg);
    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);
    int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64


    ​      

      * 创建消息队列用系统调用`msgget()`来实现，这一步工作也被称为消息队列的初始化。 

      * 在进行通信时，消息队列的发送和接收分别用系统调用`msgsnd()`和`msgrcv()`来实现.。 

      * 在需要改变队列的使用权限及其它一些特性时，用`msgclt()`来实现。 

    ######  示例代码（来自 [ https://blog.csdn.net/ljianhui/article/details/10287879）](https://blog.csdn.net/ljianhui/article/details/10287879%EF%BC%89)
    * 😘msgreceive.c

      ```c
      #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[BUFSIZ];
      };
       
      int main()
      {
      	int running = 1;
      	int msgid = -1;
      	struct msg_st data;
      	long int msgtype = 0; //注意1
       
      	//建立消息队列
      	msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
      	if(msgid == -1)
      	{
      		fprintf(stderr, "msgget failed with error: %d\n", errno);
      		exit(EXIT_FAILURE);
      	}
          
      	//从队列中获取消息，直到遇到end消息为止
      	while(running)
      	{
      		if(msgrcv(msgid, (void*)&data, BUFSIZ, msgtype, 0) == -1)
      		{
      			fprintf(stderr, "msgrcv failed with errno: %d\n", errno);
      			exit(EXIT_FAILURE);
      		}
      		printf("You wrote: %s\n",data.text);
      		//遇到end结束
      		if(strncmp(data.text, "end", 3) == 0)
      			running = 0;
      	}
          
      	//删除消息队列
      	if(msgctl(msgid, IPC_RMID, 0) == -1)
      	{
      		fprintf(stderr, "msgctl(IPC_RMID) failed\n");
      		exit(EXIT_FAILURE);
      	}
      	exit(EXIT_SUCCESS);
      }

  • 😘msgsend.c文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <sys/msg.h>
    #include <errno.h>
     
    #define MAX_TEXT 512
    struct msg_st
    {
    	long int msg_type;
    	char text[MAX_TEXT];
    };
     
    int main()
    {
    	int running = 1;
    	struct msg_st data;
    	char buffer[BUFSIZ];
    	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);
    	}
     
    	//向消息队列中写消息，直到写入end
    	while(running)
    	{
    		//输入数据
    		printf("Enter some text: ");
    		fgets(buffer, BUFSIZ, stdin);
    		data.msg_type = 1;    //注意2
    		strcpy(data.text, buffer);
    		//向队列发送数据
    		if(msgsnd(msgid, (void*)&data, MAX_TEXT, 0) == -1)
    		{
    			fprintf(stderr, "msgsnd failed\n");
    			exit(EXIT_FAILURE);
    		}
    		//输入end结束输入
    		if(strncmp(buffer, "end", 3) == 0)
    			running = 0;
    		sleep(1);
    	}
    	exit(EXIT_SUCCESS);
    }
信号量

  • 它是一个计数器，用于为多个进程提供对共享数据对象的访问

  • semget()用于创建一个新信号量或返回一个已有信号量（根据IPCkey）

  • semop()用于改变信号量的值，用于对信号量增减操作，即PV操作

  • semclt()用于直接控制信号量的值，用于对信号量初始化操作 

    1
    2
    3
    int semget(key_t key, int num_sems, int sem_flags);
    int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);
    int semctl(int sem_id, int sem_num, int command, ...);
示例代码（来自 https://blog.csdn.net/ljianhui/article/details/10243617）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h>
 
union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short *arry;
};
 
static int sem_id = 0;
 
static int set_semvalue();
static void del_semvalue();
static int semaphore_p();
static int semaphore_v();
 
int main(int argc, char *argv[])
{
	char message = 'X';
	int i = 0;
 
	//创建信号量
	sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);
 
	if(argc > 1)
	{
		//程序第一次被调用，初始化信号量
		if(!set_semvalue())
		{
			fprintf(stderr, "Failed to initialize semaphore\n");
			exit(EXIT_FAILURE);
		}
		//设置要输出到屏幕中的信息，即其参数的第一个字符
		message = argv[1][0];
		sleep(2);
	}
	for(i = 0; i < 10; ++i)
	{
		//进入临界区
		if(!semaphore_p())
			exit(EXIT_FAILURE);
		//向屏幕中输出数据
		printf("%c", message);
		//清理缓冲区，然后休眠随机时间
		fflush(stdout);
		sleep(rand() % 3);
		//离开临界区前再一次向屏幕输出数据
		printf("%c", message);
		fflush(stdout);
		//离开临界区，休眠随机时间后继续循环
		if(!semaphore_v())
			exit(EXIT_FAILURE);
		sleep(rand() % 2);
	}
 
	sleep(10);
	printf("\n%d - finished\n", getpid());
 
	if(argc > 1)
	{
		//如果程序是第一次被调用，则在退出前删除信号量
		sleep(3);
		del_semvalue();
	}
	exit(EXIT_SUCCESS);
}
 
static int set_semvalue()
{
	//用于初始化信号量，在使用信号量前必须这样做
	union semun sem_union;
 
	sem_union.val = 1;
	if(semctl(sem_id, 0, SETVAL, sem_union) == -1)
		return 0;
	return 1;
}
 
static void del_semvalue()
{
	//删除信号量
	union semun sem_union;
 
	if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
		fprintf(stderr, "Failed to delete semaphore\n");
}
 
static int semaphore_p()
{
	//对信号量做减1操作，即等待P（sv）
	struct sembuf sem_b;
	sem_b.sem_num = 0;
	sem_b.sem_op = -1;//P()
	sem_b.sem_flg = SEM_UNDO;
	if(semop(sem_id, &sem_b, 1) == -1)
	{
		fprintf(stderr, "semaphore_p failed\n");
		return 0;
	}
	return 1;
}
 
static int semaphore_v()
{
	//这是一个释放操作，它使信号量变为可用，即发送信号V（sv）
	struct sembuf sem_b;
	sem_b.sem_num = 0;
	sem_b.sem_op = 1;//V()
	sem_b.sem_flg = SEM_UNDO;
	if(semop(sem_id, &sem_b, 1) == -1)
	{
		fprintf(stderr, "semaphore_v failed\n");
		return 0;
	}
	return 1;
}
共享内存

  • 允许多个进程共享一个给定的存储区

  • 因为数据不需要进程之间的复制，而是直接访问内存，所以这是最快的一种IPC。

  • 由于共享内存并不提供同步操作，所以在使用共享内存这种通信方式时，需要借助其他手段进行进程间的同步工作，可以使用信号量等

  • shmget()用来创建共享内存，返回一个与key相关的共享内存标识符

  • shmat()用来启动对共享内存的访问，并把共享内存连接到当前进程的地址空间（第一次创建完共享内存时，还不能被任何进程访问），返回指向共享内存的指针

  • shmclt()用来控制共享内存，与信号量的semclt()函数一样

  • shmdt()用于将共享内存从当前进程中分离，注意分离不等于删除共享内存 

    1
    2
    3
    4
    int shmget(key_t key, size_t size, int shmflg);
    void *shmat(int shm_id, const void *shm_addr, int shmflg);
    int shmctl(int shm_id, int command, struct shmid_ds *buf);
    int shmdt(const void *shmaddr);
示例代码（来自 https://blog.csdn.net/ljianhui/article/details/10253345）

  • 😀shmdata.h文件，定义共享内存结构

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //shmdata.h文件，定义共享内存结构
    #ifndef _SHMDATA_H_HEADER
    #define _SHMDATA_H_HEADER 
    #define TEXT_SZ 2048
    struct shared_use_st
    {
    	int written;//作为一个标志，非0：表示可读，0表示可写
    	char text[TEXT_SZ];//记录写入和读取的文本
    };
    #endif

  • 😀shmread.c文件，创建共享内存，并读取其中信息

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/shm.h>
    #include "shmdata.h"
     
    int main()
    {
    	int running = 1;//程序是否继续运行的标志
    	void *shm = NULL;//分配的共享内存的原始首地址
    	struct shared_use_st *shared;//指向shm
    	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);
    	}
    	//将共享内存连接到当前进程的地址空间
    	shm = shmat(shmid, 0, 0);
    	if(shm == (void*)-1)
    	{
    		fprintf(stderr, "shmat failed\n");
    		exit(EXIT_FAILURE);
    	}
    	printf("\nMemory attached at %X\n", (int)shm);
    	//设置共享内存
    	shared = (struct shared_use_st*)shm;
    	shared->written = 0;
    	while(running)//读取共享内存中的数据
    	{
    		//没有进程向共享内存定数据有数据可读取
    		if(shared->written != 0)
    		{
    			printf("You wrote: %s", shared->text);
    			sleep(rand() % 3);
    			//读取完数据，设置written使共享内存段可写
    			shared->written = 0;
    			//输入了end，退出循环（程序）
    			if(strncmp(shared->text, "end", 3) == 0)
    				running = 0;
    		}
    		else//有其他进程在写数据，不能读取数据
    			sleep(1);
    	}
    	//把共享内存从当前进程中分离
    	if(shmdt(shm) == -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);
    }

  • 😀shmwrite.c文件，向共享内存写入数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <sys/shm.h>
    #include "shmdata.h"
     
    int main()
    {
    	int running = 1;
    	void *shm = NULL;
    	struct shared_use_st *shared = NULL;
    	char buffer[BUFSIZ + 1];//用于保存输入的文本
    	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);
    	}
    	//将共享内存连接到当前进程的地址空间
    	shm = shmat(shmid, (void*)0, 0);
    	if(shm == (void*)-1)
    	{
    		fprintf(stderr, "shmat failed\n");
    		exit(EXIT_FAILURE);
    	}
    	printf("Memory attached at %X\n", (int)shm);
    	//设置共享内存
    	shared = (struct shared_use_st*)shm;
    	while(running)//向共享内存中写数据
    	{
    		//数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本
    		while(shared->written == 1)
    		{
    			sleep(1);
    			printf("Waiting...\n");
    		}
    		//向共享内存中写入数据
    		printf("Enter some text: ");
    		fgets(buffer, BUFSIZ, stdin);
    		strncpy(shared->text, buffer, TEXT_SZ);
    		//写完数据，设置written使共享内存段可读
    		shared->written = 1;
    		//输入了end，退出循环（程序）
    		if(strncmp(buffer, "end", 3) == 0)
    			running = 0;
    	}
    	//把共享内存从当前进程中分离
    	if(shmdt(shm) == -1)
    	{
    		fprintf(stderr, "shmdt failed\n");
    		exit(EXIT_FAILURE);
    	}
    	sleep(2);
    	exit(EXIT_SUCCESS);
    }
套接字

  • 与其它通信机制不同的是，它可用于不同机器间的进程通信

  • 因特网提供了两种通信机制：流（stream）和数据报（datagram），因而套接字的类型也就分为流套接字和数据报套接字。

  • 套接字域：

    * `AF_INET`，它指的是Internet网络，结构中有IP地址和端口 
* `AF_UNIX`，表示UNIX文件系统，它就是文件输入/输出，结构中有文件路径名

  • socket()用于创建一个套接字，三个参数分别为套接字域、通信机制、协议类型

  • bind()函数把通过socket调用创建的套接字命名，从而让它可以被其他进程使用。

    * 对于AF_UNIX，调用该函数后套接字就会关联到一个文件系统路径名；
* 对于AF_INET，则会关联到一个IP端口号

  • listen()用来创建一个队列来保存未处理的请求

  • accept()用来等待客户建立对该套接字的连接，阻塞直到有客户建立连接

  • connect()用来让客户程序通过在一个未命名套接字和服务器监听套接字之间建立连接的方法来连接到服务器

  • close()用来终止服务器和客户上的套接字连接，我们应该总是在连接的两端（服务器和客户）关闭套接字 

    1
    2
    3
    4
    5
    int socket(int domain, int type, int protocol);
    int bind( int socket, const struct sockaddr *address, size_t address_len);
    int listen(int socket, int backlog);
    int accept(int socket, struct sockaddr *address, size_t *address_len);
    int connect(int socket, const struct sockaddr *address, size_t address_len);
示例代码（来自 https://blog.csdn.net/ljianhui/article/details/10477427）

  • 😡sockserver.c文件，服务器端

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
     
    int main()
    {
    	int server_sockfd = -1;
    	int client_sockfd = -1;
    	int client_len = 0;
    	struct sockaddr_in server_addr;
    	struct sockaddr_in client_addr;
    	//创建流套接字
    	server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    	//设置服务器接收的连接地址和监听的端口
    	server_addr.sin_family = AF_INET;//指定网络套接字
    	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//接受所有IP地址的连接
    	server_addr.sin_port = htons(9736);//绑定到9736端口
    	//绑定（命名）套接字
    	bind(server_sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    	//创建套接字队列，监听套接字
    	listen(server_sockfd, 5);
    	//忽略子进程停止或退出信号
    	signal(SIGCHLD, SIG_IGN);
    	
    	while(1)
    	{
    		char ch = '\0';
    		client_len = sizeof(client_addr);
    		printf("Server waiting\n");
    		//接受连接，创建新的套接字
    		client_sockfd = accept(server_sockfd, (struct sockaddr*)&client_addr, &client_len);
     
    		if(fork() == 0)
    		{
    			//子进程中，读取客户端发过来的信息，处理信息，再发送给客户端
    			read(client_sockfd, &ch, 1);
    			sleep(5);
    			ch++;
    			write(client_sockfd, &ch, 1);
    			close(client_sockfd);
    			exit(0);
    		}
    		else
    		{
    			//父进程中，关闭套接字
    			close(client_sockfd);
    		}
    	}
    }

  • 😡sockclient.c文件，客户端

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <stdio.h>
    #include <stdlib.h>
     
    int main()
    {
    	int sockfd = -1;
    	int len = 0;
    	struct sockaddr_in address;
    	int result;
    	char ch = 'A';
    	//创建流套接字
    	sockfd = socket(AF_INET, SOCK_STREAM, 0);
    	//设置要连接的服务器的信息
    	address.sin_family = AF_INET;//使用网络套接字
    	address.sin_addr.s_addr = inet_addr("127.0.0.1");//服务器地址
    	address.sin_port = htons(9736);//服务器所监听的端口
    	len = sizeof(address);
    	//连接到服务器
    	result = connect(sockfd, (struct sockaddr*)&address, len);
     
    	if(result == -1)
    	{
    		perror("ops:client\n");
    		exit(1);
    	}
    	//发送请求给服务器
    	write(sockfd, &ch, 1);
    	//从服务器获取数据
    	read(sockfd, &ch, 1);
    	printf("char form server = %c\n", ch);
    	close(sockfd);
    	exit(0);
    }
关于System V IPC

System V IPC指的是AT&T在System V.2发行版中引入的三种进程间通信工具：

  1. 信号量，用来管理对共享资源的访问
  2. 共享内存，用来高效地实现进程间的数据共享 共享内存，用来高效地实现进程间的数据共享
  3. 消息队列，用来实现进程间数据的传递。

我们把这三种工具统称为System V IPC的对象，每个对象都具有一个唯一的IPC标识符(identifier)。要保证不同的进程能够获取同一个IPC对象，必须提供一个IPC关键字(IPCkey)，内核负责把IPC关键字转换成IPC标识符。

-------------本文结束感谢您的阅读-------------