- 1【论文总结】机器学习需要知道的关键知识_a few useful things to know about machine learning
- 2计算机研究生跨考教育学,考研教育学，跨专业首选，你没有听错！
- 3网络工程师——2024自学
- 4微信小程序的登陆及通过openid换取token_微信小程序怎么得到token
- 5fiddler 经常抓不到浏览器的包_fd刷新网页没有包
- 6时间序列分析：使用Pandas探索能源数据集_德国能源数据时间序列分析
- 7C++自学笔记 非零基础（01）
- 8用电量专题-全国、煤炭行业、地级市工业用电量等多指标（部份内容已更新至2021）_逐月用电量
- 9PyTorch Dataset、DataLoader长度
- 10时间序列预测——时序卷积网络（TCN）_tcn用于时间序列分类教程
Linux的进程之间通信方式和实例：管道、命名管道、消息队列、信号、信号量、共享内存、内存映射文件、套接字_linux shell 命名管道 任务队列
赞
踩
Linux的进程之间通信方式和实例：管道、命名管道、消息队列、信号、信号量、共享内存、内存映射文件、套接字
概述：
在linux下的多个进程间的通信机制叫做IPC(Inter-Process Communication)，它是多个进程之间相互沟通的一种方法。在linux下有多种进程间通信的方法：半双工管道、命名管道、消息队列、信号、信号量、共享内存、内存映射文件，套接字等等。使用这些机制可以为linux下的网络服务器开发提供灵活而又坚固的框架。本文分别简述了这八种方式，并给出了一些实例。
目录
Linux的进程之间通信方式和实例：管道、命名管道、消息队列、信号、信号量、共享内存、内存映射文件、套接字... 1
给出例程：涉及到两个文件fifo_read.c和fifo_write.c. 7
这里总结一下name pipe 需要注意的事项：... 12
实例1：一个程序，自己发消息，然后自己再从队列上读消息... 22
实例2：一个程序发送消息 另一个接收消息，读的是第一条消息不判断是不是自己想要的消息 25
给出实例：两个进程通过映射普通文件实现共享内存通信... 44
- 管道（PIPE）
管道实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端将其读取出来。
管道的特点：
1、管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
2、 只能用于父子进程或者兄弟进程之间（ 具有亲缘关系的进程）。 比如fork或exec创建的新进程， 在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。 当父进程与使用fork创建的子进程直接通信时，发送数据的进程关闭读端，接受数据的进程关闭写端。管道只能在本地计算机中使用，而不可用于网络间的通信。
3、单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
4、数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
管道的实现机制： 管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道可以被循环利用。当管道中没有信息的话，从管道中读取的进程会等待，直到另一端的进程放入信息。当管道被放满信息的时候，尝试放入信息的进程会等待，直到另一端的进程取出信息。当两个进程都终结的时候，管道也自动消失。
pipe函数原型：
#include <unistd.h>
int pipe(int file_descriptor[2]);//建立管道，该函数在数组上填上两个新的文件描述符后返回0，失败返回-1。
eg.int fd[2]
int result = pipe(fd);
通过使用底层的read和write调用来访问数据。 向 file_descriptor[1]写 数据，从 file_descriptor[0]中 读数据。写入与读取的顺序原则是 先进先出。
管道读写规则：
当没有数据可读时
O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
当管道满的时候
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
如果所有管道写端对应的文件描述符被关闭，则read返回0
如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE
当要写入的数据量不大于PIPE_BUF（Posix.1要求PIPE_BUF至少 512字节）时，linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
给出实例：（父子进程之间通信）
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int fd[2];
pid_t pid;
char buf[64]="I am parent process!\n";
char line[64];
if(0!=pipe(fd))
{
fprintf(stderr,"Fail to create pipe!\n");
return 0;
}
pid = fork();
if(pid <0)
{
fprintf(stderr,"Fail to create process!\n");
return 0;
}
else if(0<pid)
{
close(fd[0]);
write(fd[1],buf,strlen(buf));
close(fd[1]);
}
else
{
close(fd[1]);
read(fd[0],line,64);
printf("DATA from Parent:%s",line);
close(fd[0]);
}
return 0;
}
- 命名管道（FIFO）
命名管道是一种特殊类型的文件，它在系统中以文件形式存在。这样克服了管道的弊端，他可以 允许没有亲缘关系的进程间通信。
创建管道的两个系统调用原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename,mode_t mode); //建立一个名字为filename的命名管道，参数mode为该文件的权限（mode%~umask），若成功则返回0，否则返回-1，错误原因存于errno中。
eg.mkfifo( "/tmp/cmd_pipe", S_IFIFO | 0666 );
具体操作方法只要创建了一个命名管道然后就可以使用open、read、write等系统调用来操作。创建可以手工创建或者程序中创建。
int mknod(const char *path, mode_t mode, dev_t dev); //第一个参数表示你要创建的文件的名称，第二个参数表示文件类型，第三个参数表示该文件对应的设备文件的设备号。只有当文件类型为 S_IFCHR 或 S_IFBLK 的时候该文件才有设备号，创建普通文件时传入0即可。
eg.mknod(FIFO_FILE,S_IFIFO|0666,0);
管道和命名管道的区别：
对于命名管道FIFO来说，IO操作和普通管道IO操作基本一样，但是两者有一个主要的区别，在命名管道中，管道可以是事先已经创建好的，比如我们在命令行下执行
mkfifo myfifo
就是创建一个命名通道，我们必须用open函数来显示地建立连接到管道的通道，而在管道中，管道已经在主进程里创建好了，然后在fork时直接复制相关数据或者是用exec创建的新进程时把管道的文件描述符当参数传递进去。
一般来说FIFO和PIPE一样总是处于阻塞状态。也就是说如果命名管道FIFO打开时设置了读权限，则读进程将一直阻塞，一直到其他进程打开该FIFO并向管道写入数据。这个阻塞动作反过来也是成立的。如果不希望命名管道操作的时候发生阻塞，可以在open的时候使用O_NONBLOCK标志，以关闭默认的阻塞操作。
给出例程：涉及到两个文件fifo_read.c和fifo_write.c
// filename:fifo_write.c
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int data_fd = -1;
int res = 0;
static int i = 0;
const int open_mode = O_WRONLY;
char buffer[PIPE_BUF + 1];
char test_data[PIPE_BUF];
if(access(fifo_name, F_OK) == -1)
{
printf ("Create the fifo pipe.\n");
res = mkfifo(fifo_name, 0777);
if(res != 0)
{
fprintf(stderr, "Could not create fifo %s\n", fifo_name);
exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONLY\n", getpid());
pipe_fd = open(fifo_name, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if(pipe_fd !=-1)
{
while(1)
{
sprintf(test_data,"test number %d \n",i++);
printf("Process %d write data to name pipe: %s",getpid(),test_data);
res = write(pipe_fd, test_data, PIPE_BUF);
if(res == -1)
{
printf("write error on name pipe !\n");
exit(EXIT_FAILURE);
}
else
{
sleep(2);
}
}
}
else
{
exit(EXIT_FAILURE);
}
close(pipe_fd);
}
下面程序fifo_read.c周期的从管道中读取数据：
// filename:fifo_read.c
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <string.h>
int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int res = 0;
int open_mode = O_RDONLY;
char buffer[PIPE_BUF + 1];
int bytes_read = 0;
int bytes_write = 0;
memset(buffer, '\0', sizeof(buffer));
printf("Process %d opening FIFO O_RDONLY\n", getpid());
pipe_fd = open(fifo_name, open_mode);
printf("Process %d result %d\n",getpid(), pipe_fd);
if(pipe_fd != -1)
{
while(1)
{
res = read(pipe_fd, buffer, PIPE_BUF);
if(res>0)
{
printf("Process %d read data from name pipe :%s",getpid(),buffer);
}
sleep(2);
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);
exit(EXIT_SUCCESS);
}
这里总结一下name pipe 需要注意的事项：
1、就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程就会读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递。
2、就是传递给open调用的是FIFO的路径名，而不是正常的文件。（如：const char *fifo_name = "/tmp/my_fifo"; ）
3、第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的。
4、关于阻塞问题：
对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。
对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。
5、管道安全问题：
有一种情况是：一个FIFO文件，有多个进程同时向同一个FIFO文件写数据，而只有一个读FIFO进程在同一个FIFO文件中读取数据时，会发生数据块的相互交错。不同进程向一个FIFO读进程发送数据是很普通的情况。这个问题的解决方法，就是让写操作的原子化。系统规定：在一个以O_WRONLY（即阻塞方式）打开的FIFO中， 如果写入的数据长度小于等待PIPE_BUF，那么或者写入全部字节，或者一个字节都不写入。如果所有的写请求都是发往一个阻塞的FIFO的，并且每个写记请求的数据长度小于等于PIPE_BUF字节，系统就可以确保数据决不会交错在一起。
- 信号 （signal）
信号机制是unix系统中最为古老的进程之间的通信机制，用于一个或几个进程之间传递异步信号。信号可以有各种异步事件产生，比如键盘中断等。shell也可以使用信号将作业控制命令传递给它的子进程。
在此列出几个简单使用方法定义：
#include <sys/types.h>
#include <signal.h>
void (*signal(int sig,void (*func)(int)))(int); //用于截取系统信号，第一个参数为信号，第二个参数为对此信号挂接用户自己的处理函数指针。返回值为以前信号处理程序的指针。
eg.int ret = signal(SIGSTOP, sig_handle);
由于signal不够健壮，推荐使用sigaction函数。
int kill(pid_t pid,int sig); //kill函数向进程号为pid的进程发送信号，信号值为sig。当pid为0时，向当前系统的所有进程发送信号sig。
int raise(int sig);//向当前进程中自举一个信号sig, 即向当前进程发送信号。
#include <unistd.h>
unsigned int alarm(unsigned int seconds); //alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数seconds为0,则之前设置的闹钟会被取消,并将剩下的时间返回。使用alarm函数的时候要注意alarm函数的覆盖性，即在一个进程中采用一次alarm函数则该进程之前的alarm函数将失效。
int pause(void); //使调用进程（或线程）睡眠状态，直到接收到信号，要么终止，或导致它调用一个信号捕获函数。
给出实例：signal3.c
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
static int alarm_fired = 0;
void ouch(int sig)
{
alarm_fired = 1;
}
int main()
{
pid_t pid;
pid = fork();
switch(pid)
{
case -1:
perror("fork failed\n");
exit(1);
case 0:
//子进程
sleep(5);
//向父进程发送信号
kill(getppid(), SIGALRM);
exit(0);
default:;
}
//设置处理函数
signal(SIGALRM, ouch);
while(!alarm_fired)
{
printf("Hello World!\n");
sleep(1);
}
if(alarm_fired)
printf("\nI got a signal %d\n", SIGALRM);
exit(0);
}
在代码中使用fork调用复制了一个新进程，在子进程中，5秒后向父进程中发送一个SIGALRM信号，父进程中捕获这个信号，并用ouch函数来处理，变改alarm_fired的值，然后退出循环。从结果中我们也可以看到输出了5个Hello World！之后，程序就收到一个SIGARLM信号，然后结束了进程。
- 消息队列（Message queues）
消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用 IPC标识符 唯一地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。每个消息队列中的消息，又构成一个 独立的链表。
消息队列克服了信号承载信息量少，管道只能承载无格式字符流。
消息队列头文件：
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/msg.h>
消息队列的数据结构
1、 消息缓冲区结构：
struct msgbuf{
long mtype;
char mtext[1];//柔性数组
}
在结构中有两个成员，mtype为消息类型，用户可以给某个消息设定一个类型，可以在消息队列中正确地发送和接受自己的消息。mtext为消息数据，采用柔性数组，用户可以重新定义msgbuf结构。例如：
struct msgbuf{
long mtype;
char mtext[1];//柔性数组
}
当然用户不可随意定义msgbuf结构，因为在linux中消息的大小是有限制的，在linux/msg.h中定义如下：
#define MSGMAX 8192
消息总的大小不能超过8192个字节，包括mtype成员（4个字节）。
2、msqid_ds内核数据结构。
msgqid_ds结构被系统内核用来保存消息队列对象有关数据。内核中存在的每个消息队列对象系统都保存一个msgqid_ds结构的数据存放该对象的各种信息。在Linux 的库文件linux/msg.h 中，它的定义是这样的：
struct msqid_ds {
struct ipc_perm msg_perm;
struct msg *msg_first;
struct msg *msg_last;
__kernel_time_t msg_stime;
__kernel_time_t msg_rtime;
__kernel_time_t msg_ctime;
struct wait_queue *wwait;
struct wait_queue *rwait;
unsigned short msg_cbytes;
unsigned short msg_qnum;
unsigned short msg_qbytes;
__kernel_ipc_pid_t msg_lspid;
__kernel_ipc_pid_t msg_lrpid;
};其中，msg_perm成员保存了消息队列的存取权限以及其他一些信息(见下面关于ipc_perm结构的介绍)。
msg_first
成员指针保存了消息队列(链表)中第一个成员的地址。
msg_last
成员指针保存了消息队列中最后一个成员的地址。
msg_stime 成员保存了最近一次队列接受消息的时间。
msg_rtime成员保存了最近一次从队列中取出消息的时间。
msg_ctime 成员保存了最近一次队列发生改动的时间。
wwait 和rwait 是指向系统内部等待队列的指针。
msg_cbytes 成员保存着队列总共占用内存的字节数。
msg_qnum 成员保存着队列里保存的消息数目。
msg_qbytes 成员保存着队列所占用内存的最大字节数。
msg_lspid成员保存着最近一次向队列发送消息的进程的pid。
msg_lrpid 成员保存着最近一次从队列中取出消息的进程的pid。
Linux内核中，每个消息队列都维护一个结构体，此结构体保存着消息队列当前状态信息，该结构体在头文件linux/msg.h中定义。
3、ipc_perm内核数据结构
struct ipc_perm{
key_t key;
uid_t uid;
gid_t gid;
.......
};
结构体ipc_perm保存着消息队列的一些重要的信息，比如说消息队列关联的键值，消息队列的用户id组id等。它定义在头文件linux/ipc.h中。
常用函数：
系统建立IPC通讯 （消息队列、信号量和共享内存） 时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。
key_t ftok( const char * fname, int id );//参数一为目录名称, 参数二为id。如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key_t返回值为0x26010002。
eg.key_t key = key =ftok(".", 1);
int msgget(key_t key,int msgflag); //msgget用来创建和访问一个消息队列。程序必须提供一个键值来命名特定的消息队列。
eg.int msg_id = msgget(key, IPC_CREATE | IPC_EXCL | 0x0666);//根据关键字创建一个新的队列(IPC_CREATE)，如果队列存在则出错(IPC_EXCL)，拥有对文件的读写执行权限(0666)。
int msgsnd(int msgid,const void *msgptr,size_t msg_sz,int msgflg); //msgsnd函数允许我们把一条消息添加到消息队列中。msgptr只想准备发送消息的指针，指针结构体必须以一个长整型变量开始。
eg.struct msgmbuf{
int mtype;
char mtext[10];
};
struct msgmbuf msg_mbuf;
msg_mbuf.mtype = 10;//消息大小10字节
memcpy(msg_mbuf.mtext, "测试消息", sizeof("测试消息"));
int ret = msgsnd(msg_id, &msg_mbuf, sizeof("测试消息"), IPC_NOWAIT);
int msgrcv(int msgid, void *msgptr, size_t msg_sz, long int msgtype, int msgflg); //msgrcv可以通过msqid对指定消息队列进行接收操作。第二个参数为消息缓冲区变量地址，第三个参数为消息缓冲区结构大小，但是不包括mtype成员长度，第四个参数为mtype指定从队列中获取的消息类型。
eg.int ret = msgrcv(msg_id, &msg_mbuf, 10, 10, IPC_NOWAIT | MSG_NOERROR);
int msgctl(int msqid,int cmd,struct msqid_ds *buf); //msgctl函数主要是一些控制如删除消息队列等操作。 cmd值如下：
IPC_STAT:获取队列的msgid_ds结构，并把它存到buf指向的地址。
IPC_SET:将队列的msgid_ds设置为buf指向的msgid_ds。
IPC_RMID:内核删除消息队列，最后一项填NULL, 执行操作后，内核会把消息队列从系统中删除。
消息队列的本质
Linux的消息队列(queue)实质上是一个链表，它有消息队列标识符(queue ID)。 msgget创建一个新队列或打开一个存在的队列；msgsnd向队列末端添加一条新消息；msgrcv从队列中取消息， 取消息是不一定遵循先进先出的， 也可以按消息的类型字段取消息。
消息队列与命名管道的比较
消息队列跟命名管道有不少的相同之处，通过与命名管道一样，消息队列进行通信的进程可以是不相关的进程，同时它们都是通过发送和接收的方式来传递数据的。在命名管道中，发送数据用write，接收数据用read，则在消息队列中，发送数据用msgsnd，接收数据用msgrcv。而且它们对每个数据都有一个最大长度的限制。
与命名管道相比，消息队列的优势在于，1、消息队列也可以独立于发送和接收进程而存在，从而消除了在同步命名管道的打开和关闭时可能产生的困难。2、同时通过发送消息还可以避免命名管道的同步和阻塞问题，不需要由进程自己来提供同步方法。3、接收程序可以通过消息类型有选择地接收数据，而不是像命名管道中那样，只能默认地接收。
实例1：一个程序，自己发消息，然后自己再从队列上读消息
/*msgque.c*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define BUFSZ 512
struct message
{
long msg_type;
char msg_text[BUFSZ];
};
int main()
{
int qid;
key_t key;
int len;
struct message msg;
/*根据不同的路径和关键表示产生标准的key*/
if ((key = ftok(".", 'a')) == -1)
{
perror("ftok");
exit(1);
}
/*创建消息队列*/
if ((qid = msgget(key,IPC_CREAT|0666)) == -1)
{
perror("msgget");
exit(1);
}
printf("Opened queue %d\n",qid);
puts("Please enter the message to queue:");
if ((fgets((&msg)->msg_text, BUFSZ, stdin)) == NULL) //消息内容
{
puts("no message");
exit(1);
}
msg.msg_type = getpid(); //消息类型，可以理解为发信人名字
len = strlen(msg.msg_text);
/*添加消息到消息队列*/
if ((msgsnd(qid, &msg, len, 0)) < 0) //把消息加到队列
{
perror("message posted");
exit(1);
}
/*读取消息队列*/
if (msgrcv(qid, &msg, BUFSZ, getpid(), 0) < 0) //读发信人为getpid()的消息
{
perror("msgrcv");
exit(1);
}
printf("message is:%s\n",(&msg)->msg_text);
/*从系统内核中移走消息队列 */
if ((msgctl(qid, IPC_RMID, NULL)) < 0)
{
perror("msgctl");
exit(1);
}
exit(0);
}
实例2：一个程序发送消息 另一个接收消息，读的是第一条消息不判断是不是自己想要的消息
/* msgsnd.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define BUFFER_SIZE 512
struct message
{
long msg_type;
char msg_text[BUFFER_SIZE];
};
int main()
{
int qid;
key_t key;
struct message msg;
/*根据不同的路径和关键表示产生标准的key*/
if ((key = ftok(".", 'a')) == -1)
{
perror("ftok");
exit(1);
}
/*创建消息队列*/
if ((qid = msgget(key, IPC_CREAT|0666)) == -1)
{
perror("msgget");
exit(1);
}
printf("Open queue %d\n",qid);
while(1)
{
printf("Enter some message to the queue(enter 'quit' to exit):");
if ((fgets(msg.msg_text, BUFFER_SIZE, stdin)) == NULL)
{
puts("no message");
exit(1);
}
msg.msg_type = getpid();
/*添加消息到消息队列*/
if ((msgsnd(qid, &msg, strlen(msg.msg_text), 0)) < 0)
{
perror("message posted");
exit(1);
}
if (strncmp(msg.msg_text, "quit", 4) == 0)
{
break;
}
}
exit(0);
}
/* msgrcv.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <lt;stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define BUFFER_SIZE 512
struct message
{
long msg_type;
char msg_text[BUFFER_SIZE];
};
int main()
{
int qid;
key_t key;
struct message msg;
/*根据不同的路径和关键表示产生标准的key*/
if ((key = ftok(".", 'a')) == -1)
{
perror("ftok");
exit(1);
}
/*创建消息队列*/
if ((qid = msgget(key, IPC_CREAT|0666)) == -1)
{
perror("msgget");
exit(1);
}
printf("Open queue %d\n", qid);
do
{
/*读取消息队列*/
memset(msg.msg_text, 0, BUFFER_SIZE);
if (msgrcv(qid, (void*)&msg, BUFFER_SIZE, 0, 0) < 0) //读取消息不管是谁发的
{
perror("msgrcv");
exit(1);
}
printf("The message from process %d : %s", msg.msg_type, msg.msg_text);
} while(strncmp(msg.msg_text, "quit", 4));
/*从系统内核中移走消息队列 */
if ((msgctl(qid, IPC_RMID, NULL)) < 0)
{
perror("msgctl");
exit(1);
}
exit(0);
}
- 信号量（Semaphore）
信号量是一种计数器，用于控制对多个进程共享的资源进行的访问。它们常常被用作一个锁机制，在某个进程正在对特定的资源进行操作时，信号量可以防止另一个进程去访问它。
信号量是特殊的变量，它只取正整数值并且只允许对这个值进行两种操作：等待（wait）和信号（signal）。（P、V操作，P用于等待，V用于信号）p(sv):如果sv的值大于0，就给它减1；如果它的值等于0，就挂起该进程的执行
V(sv):如果有其他进程因等待sv而被挂起，就让它恢复运行；如果没有其他进程因等待sv而挂起，则给它加1，简单理解就是P相当于申请资源，V相当于释放资源。
信号量头文件：
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sem.h>
内核为每个信号量集合都维护一个semid_ds结构：
struct semid_ds{
struct ipc_perm sem_perm;
unsigned short sem_nsems;
time_t sem_otime;
time_t sem_ctime;
...
}
信号量数据结构：
union semun{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
}
信号量操作sembuf结构：
struct sembuf{
ushort sem_num;//信号量的编号
short sem_op;//信号量的操作。如果为正，则从信号量中加上一个值，如果为负，则从信号量中减掉一个值，如果为0，则将进程设置为睡眠状态，直到信号量的值为0为止。
short sem_flg;//信号的操作标志，一般为IPC_NOWAIT。
}
常用函数：
int semget(key_t key, int num_sems, int sem_flags); //semget函数用于创建一个新的信号量集合 ， 或者访问一个现有的集合（不同进程只要key值相同即可访问同一信号量集合）。第一个参数key是ftok生成的键值，第二个参数num_sems可以指定在新的集合应该创建的信号量的数目，第三个参数sem_flags是打开信号量的方式。
eg.int semid = semget(key, 0, IPC_CREATE | IPC_EXCL | 0666);//第三个参数参考消息队列int msgget(key_t key,int msgflag);第二个参数。
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops); //semop函数用于改变信号量的值。第二个参数是要在信号集合上执行操作的一个数组，第三个参数是该数组操作的个数 。
eg.struct sembuf sops = {0, +1, IPC_NOWAIT};//对索引值为0的信号量加一。
semop(semid, &sops, 1);//以上功能执行的次数为一次。
int semctl(int sem_id, int sem_num, int command,...); //semctl函数用于信号量集合执行控制操作，初始化信号量的值，删除一个信号量等。 类似于调用msgctl()， msgctl()是用于消息队列上的操作。第一个参数是指定的信号量集合（semget的返回值），第二个参数是要执行操作的信号量在集合中的索引值（例如集合中第一个信号量下标为0），第三个command参数代表要在集合上执行的命令。
IPC_STAT:获取某个集合的semid_ds结构，并把它存储到semun联合体的buf参数指向的地址。
IPC_SET:将某个集合的semid_ds结构的ipc_perm成员的值。该命令所取的值是从semun联合体的buf参数中取到。
IPC_RMID:内核删除该信号量集合。
GETVAL:返回集合中某个信号量的值。
SETVAL:把集合中单个信号量的值设置成为联合体val成员的值。
给出实例：使用信号量在父子进程之间通信
（此处的实例是从别的地方引用过来的，发现使用信号量进行进程之间进行消息传递的真的很少）：写一个程序，该程序创建两个进程，分别打印"this is the child process"和"father say hello to child"，要求交替打印，输出成"this father is say the hello child to process child"，每打印一个单词进程阻塞一段时间。将输出打印到当前目录下的tmp文件中。
- #include <stdio.h>
- #include <stdlib.h>
- #include <sys/types.h>
- #include <sys/ipc.h>
- #include <sys/sem.h>
- #include <sys/stat.h>
- #include <fcntl.h>
- union semun
- {
- int val;
- struct semid_ds *buf;
- unsigned short int *array;
- struct seminfo *__buf;
- };
- int main(void)
- {
- char* buf_child[]={"this", "is", "the", "child", "process"};
- char* buf_father[]={"father", "say", "hello", "to", "child"};
- int i = 0, semid, fd;
- pid_t pid;
- struct sembuf sb; //信号量操作
- union semun sem;
- semid = semget(1000, 2, 0666 | IPC_CREAT); //申请信号量组，包含2个信号量
- sem.val = 0;
- semctl(semid, 0, SETVAL, sem); //初始化0号信号量为0
- sem.val = 1;
- semctl(semid, 1, SETVAL, sem); //初始化1号信号量为1
- fd=open("tmp",O_CREAT|O_TRUNC|O_WRONLY,0666);
- pid = fork();
- switch (pid) {
- case -1:
- perror("fork fail");
- break;
- case 0: /* child consume */
- srand((unsigned int)getpid());
- while (i < 5) {
- sb.sem_num = 1; //将1号信号量
- sb.sem_op = -1; //减1
- sb.sem_flg = sb.sem_flg & ~IPC_NOWAIT;
- semop(semid, &sb, 1);
- write(fd,buf_child[i], strlen(buf_child[i]));
- sleep(rand());
- write(fd,&" ", 1);
- i++;
- sb.sem_num = 0; //将0号信号量
- sb.sem_op = 1; //加1
- sb.sem_flg = sb.sem_flg & ~IPC_NOWAIT;
- semop(semid, &sb, 1); //操作信号量
- }
- break;
- default:/* parent production */
- srand((unsigned int)getpid());
- while (i < 5) {
- sb.sem_num = 0; //将0号信号量
- sb.sem_op = -1; //减1
- sb.sem_flg = sb.sem_flg & ~IPC_NOWAIT;
- semop(semid, &sb, 1); //操作信号量
- write(fd,buf_father[i], strlen(buf_father[i]));
- sleep(rand());
- write(fd,&" ", 1);
- i++;
- sb.sem_num = 1;
- sb.sem_op = 1;
- sb.sem_flg = sb.sem_flg & ~IPC_NOWAIT;
- semop(semid, &sb, 1);
- }
- break;
- }
- return 0;
- }
- 共享内存（Share Memory）
共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，由IPC为进程创建的一个特殊地址范围，它将出现在该进程的地址空间中。其他进程可以将 同一段共享内存连接到自己的地址空间中。所有进程都可以访问共享内存中的地址，就好像它们是malloc分配的一样。如果一个进程向共享内存中写入了数据，所做的改动将立刻被其他进程看到。
共享内存是 IPC最快捷的方式，因为共享内存方式的通信没有中间过程，而管道、消息队列等方式则是需要将数据通过中间机制进行转换。共享内存方式直接将某段内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅映射到各进程的地址不同而已，因此不需要进行复制，可以直接使用此段空间。
注意：共享内存本身并没有同步机制，需要程序员自己控制。
共享内存头文件：
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/shm.h>
结构shmid_ds结构体（是不是很眼熟，看消息队列的 msgid_ds结构体）：
strcut shmid_ds{
struct ipc_perm shm_perm;
size_t shm_segsz;
time_t shm_atime;
time_t shm_dtime;
......
}
共享内存函数定义：
int shmget(key_t key,size_t size,int shmflg); //shmget函数用来创建一个新的共享内存段， 或者访问一个现有的共享内存段（不同进程只要key值相同即可访问同一共享内存段）。第一个参数key是ftok生成的键值，第二个参数size为共享内存的大小，第三个参数sem_flags是打开共享内存的方式。
eg.int shmid = shmget(key, 1024, IPC_CREATE | IPC_EXCL | 0666);//第三个参数参考消息队列int msgget(key_t key,int msgflag);
void *shmat(int shm_id,const void *shm_addr,int shmflg); //shmat函数通过shm_id将共享内存连接到进程的地址空间中。第二个参数可以由用户指定共享内存映射到进程空间的地址，shm_addr如果为0，则由内核试着查找一个未映射的区域。返回值为共享内存映射的地址。
eg.char *shms = (char *)shmat(shmid, 0, 0);//shmid由shmget获得
int shmdt(const void *shm_addr); //shmdt函数将共享内存从当前进程中分离。 参数为共享内存映射的地址。
eg.shmdt(shms);
int shmctl(int shm_id,int cmd,struct shmid_ds *buf);//shmctl函数是控制函数，使用方法和消息队列msgctl()函数调用完全类似。参数一shm_id是共享内存的句柄，cmd是向共享内存发送的命令，最后一个参数buf是向共享内存发送命令的参数。
消息队列、信号量以及共享内存的相似之处：
它们被统称为XSI IPC，它们在内核中有相似的IPC结构（消息队列的msgid_ds，信号量的semid_ds，共享内存的shmid_ds），而且都用一个非负整数的标识符加以引用（消息队列的msg_id，信号量的sem_id，共享内存的shm_id，分别通过msgget、semget以及shmget获得），标志符是IPC对象的内部名，每个IPC对象都有一个键（key_t key）相关联，将这个键作为该对象的外部名。
XSI IPC和PIPE、FIFO的区别：
1、XSI IPC的IPC结构是在系统范围内起作用，没用使用引用计数。如果一个进程创建一个消息队列，并在消息队列中放入几个消息，进程终止后，即使现在已经没有程序使用该消息队列，消息队列及其内容依然保留。而PIPE在最后一个引用管道的进程终止时，管道就被完全删除了。对于FIFO最后一个引用FIFO的进程终止时，虽然FIFO还在系统，但是其中的内容会被删除。
2、和PIPE、FIFO不一样，XSI IPC不使用文件描述符，所以不能用ls查看IPC对象，不能用rm命令删除，不能用chmod命令删除它们的访问权限。只能使用ipcs和ipcrm来查看可以删除它们。
给出实例：
创建共享内存，往共享内存里写入数据
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
struct sys_data{
float data_rh;
float data_t;
};
int main(){
void* shm=(void*)0;
int shmid;
struct sys_data *da=0;
float ftemp=0.0,fhumi=0.0;
shmid=shmget((key_t)8891,sizeof(struct sys_data),0666|IPC_CREAT); //创建共享内存
if(shmid == -1){
printf("shmget error\n");
exit(-1);
}else{ printf("shmid = %d\n",shmid);}
shm = shmat(shmid,(void*)0,0); //映射共享内存
if(shm == (void*)(-1)){
printf("shmat error\n");
exit(-1);
}
da = shm;
while(1){
ftemp = rand()%100;
fhumi= rand()%100;
da->data_t=ftemp;
da->data_rh=fhumi;
sleep(1);
}
}
~
将写入共享内存的内容打印出来
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
struct sys_data{
float data_rh;
float data_t;
};
int main(){
void* shm=(void*)0;
int shmid;
struct sys_data *da=0;
float ftemp=0.0,fhumi=0.0;
shmid=shmget((key_t)8891,sizeof(struct sys_data),0666|IPC_CREAT);
if(shmid == -1){
printf("shmget error\n");
exit(-1);
}else{ printf("shmid = %d\n",shmid);}
shm = shmat(shmid,(void*)0,0);
if(shm == (void*)(-1)){
printf("shmat error\n");
exit(-1);
}
da = shm;
while(1){
sleep(1);
printf("temp=%.1f,humi=%.1f\n",da->data_t,da->data_rh);
}
return 0;
}
- 内存映射（Memory Map）
内存映射文件，是由一个文件到一块内存的映射。内存映射文件与 虚拟内存有些类似，通过内存映射文件可以保留一个地址的区域，
同时将物理存储器提交给此区域，内存文件映射的物理存储器来自一个已经存在于磁盘上的文件，而且在对该文件进行操作之前必须首先对文件进行映射。使用内存映射文件处理存储于磁盘上的文件时，将不必再对文件执行I/O操作。 每一个使用该机制的进程通过把同一个共享的文件映射到自己的进程地址空间来实现多个进程间的通信（这里类似于共享内存，只要有一个进程对这块映射文件的内存进行操作，其他进程也能够马上看到）。
使用内存映射文件不仅可以实现多个进程间的通信，还可以用于 处理大文件提高效率。因为我们普通的做法是 把磁盘上的文件先拷贝到内核空间的一个缓冲区再拷贝到用户空间（内存），用户修改后再将这些数据拷贝到缓冲区再拷贝到磁盘文件，一共四次拷贝。如果文件数据量很大，拷贝的开销是非常大的。那么问题来了，系统在在进行内存映射文件就不需要数据拷贝？mmap()确实没有进行数据拷贝，真正的拷贝是在在缺页中断处理时进行的，由于mmap()将文件直接映射到用户空间，所以中断处理函数根据这个映射关系，直接将文件从硬盘拷贝到用户空间，所以只进行一次数据拷贝。效率高于read/write。
内存映射头文件：
#include <sys.mman.h>
void *mmap(void*start,size_t length,int prot,int flags,int fd,off_t offset); //mmap函数将一个文件或者其它对象映射进内存。 第一个参数为映射区的开始地址，设置为0表示由系统决定映射区的起始地址，第二个参数为映射的长度，第三个参数为期望的内存保护标志，第四个参数是指定映射对象的类型，第五个参数为文件描述符（指明要映射的文件），第六个参数是被映射对象内容的起点。成功返回被映射区的指针，失败返回MAP_FAILED[其值为(void *)-1]。
int munmap(void* start,size_t length); //munmap函数用来取消参数start所指的映射内存起始地址，参数length则是欲取消的内存大小。如果解除映射成功则返回0，否则返回－1，错误原因存于errno中错误代码EINVAL。
int msync(void *addr,size_t len,int flags); //msync函数实现磁盘文件内容和共享内存取内容一致，即同步。第一个参数为文件映射到进程空间的地址，第二个参数为映射空间的大小，第三个参数为刷新的参数设置。
共享内存和内存映射文件的区别：
内存映射文件是利用虚拟内存把文件映射到进程的地址空间中去，在此之后进程操作文件，就像操作进程空间里的地址一样了，比如使用c语言的memcpy等内存操作的函数。这种方法能够很好的应用在需要频繁处理一个文件或者是一个大文件的场合，这种方式处理IO效率比普通IO效率要高
共享内存是内存映射文件的一种特殊情况，内存映射的是一块内存，而非磁盘上的文件。共享内存的主语是进程（Process），操作系统默认会给每一个进程分配一个内存空间，每一个进程只允许访问操作系统分配给它的哪一段内存，而不能访问其他进程的。而有时候需要在不同进程之间访问同一段内存，怎么办呢？操作系统给出了 创建访问共享内存的API，需要共享内存的进程可以通过这一组定义好的API来访问多个进程之间共有的内存，各个进程访问这一段内存就像访问一个硬盘上的文件一样。
内存映射文件与虚拟内存的区别和联系：
内存映射文件和虚拟内存都是操作系统内存管理的重要部分，两者有相似点也有不同点。
联系：虚拟内存和内存映射都是将一部分内容加载到内存，另一部放在磁盘上的一种机制。对于用户而言都是透明的。
区别：虚拟内存是硬盘的一部分，是内存和硬盘的数据交换区，许多程序运行过程中把暂时不用的程序数据放入这块虚拟内存，节约内存资源。内存映射是一个文件到一块内存的映射，这样程序通过内存指针就可以对文件进行访问。
虚拟内存的硬件基础是分页机制。另外一个基础就是局部性原理（时间局部性和空间局部性），这样就可以将程序的一部分装入内存，其余部分留在外存，当访问信息不存在，再将所需数据调入内存。而内存映射文件并不是局部性，而是使虚拟地址空间的某个区域银蛇磁盘的全部或部分内容，通过该区域对被映射的磁盘文件进行访问，不必进行文件I/O也不需要对文件内容进行缓冲处理。
给出实例：两个进程通过映射普通文件实现共享内存通信
范例1包含两个子程序：map_normalfile1.c及map_normalfile2.c。编译两个程序，可执行文件分别为map_normalfile1及map_normalfile2。两个程序通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。map_normalfile2试图打开命令行参数指定的一个普通文件，把该文件映射到进程的地址空间，并对映射后的地址空间进行写操作。map_normalfile1把命令行参数指定的文件映射到进程地址空间，然后对映射后的地址空间执行读操作。这样，两个进程通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。
下面是两个程序代码：
<span style="background-color:#f7f7f7">/*-------------map_normalfile1.c-----------*/
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{
char name[4];
int age;
}people;
main(int argc, char** argv) // map a normal file as shared mem:
{
int fd,i;
people *p_map;
char temp;
fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);
lseek(fd,sizeof(people)*5-1,SEEK_SET);
write(fd,"",1);
p_map = (people*) mmap( NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,
MAP_SHARED,fd,0 );
close( fd );
temp = 'a';
for(i=0; i<10; i++)
{
temp += 1;
memcpy( ( *(p_map+i) ).name, &temp,2 );
( *(p_map+i) ).age = 20+i;
}
printf(" initialize over \n ")；
sleep(10);
munmap( p_map, sizeof(people)*10 );
printf( "umap ok \n" );
}
/*-------------map_normalfile2.c-----------*/
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{
char name[4];
int age;
}people;
main(int argc, char** argv) // map a normal file as shared mem:
{
int fd,i;
people *p_map;
fd=open( argv[1],O_CREAT|O_RDWR,00777 );
p_map = (people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,
MAP_SHARED,fd,0);
for(i = 0;i<10;i++)
{
printf( "name: %s age %d;\n",(*(p_map+i)).name, (*(p_map+i)).age );
}
munmap( p_map,sizeof(people)*10 );
}</span>
map_normalfile1.c首先定义了一个people数据结构，（在这里采用数据结构的方式是因为，共享内存区的数据往往是有固定格式的，这由通信的各个进程决定，采用结构的方式有普遍代表性）。map_normfile1首先打开或创建一个文件，并把文件的长度设置为5个people结构大小。然后从mmap()的返回地址开始，设置了10个people结构。然后，进程睡眠10秒钟，等待其他进程映射同一个文件，最后解除映射。
map_normfile2.c只是简单的映射一个文件，并以people数据结构的格式从mmap()返回的地址处读取10个people结构，并输出读取的值，然后解除映射。
套接字机制不但可以单机的不同进程通信，而且使得跨网机器间进程可以通信。套接字的创建和使用与管道是有区别的，套接字明确地将客户端与服务器区分开来，可以实现多个客户端连到同一服务器。
服务器套接字连接过程描述：
首先，服务器应用程序用socket创建一个套接字，它是系统分配服务器进程的类似文件描述符的资源。 接着，服务器调用bind给套接字命名。这个名字是一个标示符，它允许linux将进入的针对特定端口的连接转到正确的服务器进程。 然后，系统调用listen函数开始接听，等待客户端连接。listen创建一个队列并将其用于存放来自客户端的进入连接。 当客户端调用connect请求连接时，服务器调用accept接受客户端连接，accept此时会创建一个新套接字，用于与这个客户端进行通信。
客户端套接字连接过程描述：
客户端首先调用socket创建一个未命名套接字，让后将服务器的命名套接字作为地址来调用connect与服务器建立连接。
只要双方连接建立成功，我们就可以像操作底层文件一样来操作socket套接字实现通信。
几个基础函数定义：
#include <sys/types.h>
#include <sys/socket.h>
int socket(it domain,int type,int protocal);
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 *addrsss,size_t address_len);
详细请看： http://blog.csdn.net/a987073381/article/details/51869000
在socket编程中，一个服务可以接受多个客户端的连接，可以为每个客户端设定一个消息类型，服务器和客户端直接的通信可以通过此消息类型来发送和接受消息，而且多个客户端之间也可以通过消息类型来区分。
实例一：有链接的socket通信实例
1.Client部分：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define IP "127.0.0.1"
#define PORT 7788
#define MAXLEN 1024
int main(int argc,char* argv[])
{
int sock_fd = 0;
int iret = 0;
struct sockaddr_in sock_addr;
char buf[MAXLEN] = {0};
//创建socket
if((sock_fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
{
perror("socket error");
exit(1);
}
//发送连接服务器的请求
memset(&sock_addr,0,sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons(PORT);
sock_addr.sin_addr.s_addr = inet_addr(IP);
if(connect(sock_fd,(struct sockaddr*)(&sock_addr),sizeof(sock_addr))==-1)
{
perror("connect error");
exit(1);
}
printf("connect success!\n");
while(1) //发送数据
{
memset(buf,'\0',sizeof(buf));
gets(buf);
iret=write(sock_fd,buf,strlen(buf));
printf("write data:%s,len=%d\n",buf,iret);
if(strcmp(buf,"quit") == 0)
{
printf("即将退出 ...\n");
sleep(3);
break;
}
}
close(sock_fd); //关闭套接字
return 0;
}
2.server部分
#include
#include
#include
#include
#include
#include
#include
#include
#define PORT 7788
#define IP "127.0.0.1"
int main(int argc,char* argv[])
{
int sock,new_fd;
struct sockaddr_in self_addr,recv_addr;
int iret =0,len =0;
char buf[100] = {'\0'};
int fd = 0;
int ret = 0;
//创建套接字
sock = socket(AF_INET,SOCK_STREAM,0);
if(sock < 0)
{
perror("socket error");
exit(0);
}
//绑定自己的端口号
memset(&self_addr,0,sizeof(self_addr));
self_addr.sin_family = AF_INET;
self_addr.sin_port = htons(PORT);
self_addr.sin_addr.s_addr = INADDR_ANY;
if(bind(sock,(struct sockaddr*)&self_addr,sizeof(self_addr)) == -1)
{
perror("bind error");
exit(0);
}
//监听
if(listen(sock,5) == -1)
{
perror("listen error");
exit(0);
}
while(1)
{
//接受客户端的连接请求
memset(&recv_addr,0,sizeof(recv_addr));
printf("wait for connect\n");
if((new_fd = accept(sock,(struct sockaddr*)&recv_addr,&len)) == -1)
{
perror("accept error");
exit(0);
}
printf("connect ok\n");
//接收数据
while(1)
{
if(read(new_fd,buf,sizeof(buf)) <= 0) //注意加上“=”，避免客户端退出服务器读到空数据而造成死循环
{
printf("client is outline\n");
break;
}
else
printf("buf is %s\n",buf);
memset(buf,'\0',sizeof(buf));
}
}
close(new_fd);
close(sock); //关闭套接字
return 0;
}
实例2、无链接的套接字通信实例：
给出一个获取时间的例子，服务端程序负责创建Socket并且绑定到本机9090端口，然后等待客户端发出请求，当收到客户端发出的时间请求“time”之后，生成当前时间的字符串发送给客户端。客户端建立socket以后，直接向指定到服务端发送请求时间命令，之后等待服务端返回，发送退出命令，关闭链接。
// time_serv.c gcc -o s time_serv.c
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include<time.h>
#include<string.h>
#define TIME_PORT 9090
#define DATA_SIZE 256
int main()
{
int sock_fd;
struct sockaddr_in local;
struct sockaddr_in from;
int n;
socklen_t fromlen;
char buff[DATA_SIZE];
time_t cur_time;
sock_fd = socket(AF_INET, SOCK_DGRAM,0);
if(sock_fd<=0)
{
perror("create socket error!");
return 0;
}
perror("Create socket");
// 设置要绑定的IP和端口
local.sin_family = AF_INET;
local.sin_port = htons(TIME_PORT);
local.sin_addr.s_addr=INADDR_ANY;
//绑定本机到套接字
if(0!=bind(sock_fd,(struct sockaddr*)&local,sizeof(local)))
{
perror("blind socket error!");
close(sock_fd);
return 0;
}
printf("Bind socket");
fromlen=sizeof(from);
printf("waiting request from client...\n");
while(1)
{
n=recvfrom(sock_fd,buff,sizeof(buff),0,(struct sockaddr*)&from,&fromlen);
if(n<=0)
{
perror("recv data!\n");
close(sock_fd);
return 0;
}
buff[n]='\0';
printf("client request:%s\n",buff);
if(0==strncmp(buff,"quit",4))
break;
if(0==strncmp(buff,"time",4))
{
cur_time=time(NULL);
strcpy(buff,asctime(gmtime(&cur_time)));
sendto(sock_fd,buff,sizeof(buff),0,(struct sockaddr*)&from,fromlen);
}
}
close(sock_fd);
return 0;
}
/
// time_client.c gcc -o c time_client.c
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include<time.h>
#include<string.h>
#define TIME_PORT 9090
#define DATA_SIZE 256
int main()
{
int sock_fd;
struct sockaddr_in serv;
int n;
socklen_t servlen;
char buff[DATA_SIZE];
sock_fd=socket(AF_INET,SOCK_DGRAM,0);
if(sock_fd<=0)
{
perror("create socket error!");
return 0;
}
perror("Create socket");
//设置服务器IP和端口
serv.sin_family=AF_INET;
serv.sin_port=htons(TIME_PORT);
serv.sin_addr.s_addr=INADDR_ANY;
servlen = sizeof(serv);
//请求时间
strcpy(buff,"time");
if(-1==sendto(sock_fd,buff,sizeof(buff),0,(struct sockaddr*)&serv,servlen))
{
perror("send data.");
close(sock_fd);
return 0;
}
printf("send time request\n");
n=recvfrom(sock_fd,buff,sizeof(buff),0,(struct sockaddr*)&serv,&servlen);
if(n<=0)
{
perror("recv data!\n");
close(sock_fd);
return 0;
}
buff[n]='\0';
printf("time from server: %s",buff);
//退出链接
strcpy(buff,"quit");
if(-1==sendto(sock_fd,buff,sizeof(buff),0,(struct sockaddr*)&serv,servlen))
{
perror("send data.");
close(sock_fd);
return 0;
}
printf("send quit command\n");
close(sock_fd);
return 0;
}
主要参考博客：
