进程间通信的五种方式（信号量，管道，套接字，消息队列，共享内存）

最新推荐文章于 2024-04-26 17:36:11 发布

A1ke

最新推荐文章于 2024-04-26 17:36:11 发布

阅读量4.1k

点赞数 3

分类专栏：操作系统

本文链接：https://blog.csdn.net/Administrator_M/article/details/88366312

版权

操作系统专栏收录该内容

3 篇文章 0 订阅

订阅专栏

进程的概念

进程是操作系统的概念，每当我们执行一个程序时候，对于操作系统来讲就创建了一个进程，在这个过程中，伴随着资源的分配和释放。可以认为进程是一个程序的一次执行过程。

进程通信的概念

进程用户空间是相互独立的，一般而言是不能相互访问的。但是很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其他进程之间的互相通信来协调他们的行为。

进程通信的应用场景

数据传输：一个进程需要把他的数据发送给另外一个进程，发送的数据量在一个字节到几兆字节之间。
共享数据：多个进程想要操作共享数据，一个进程对数据的修改，其他进程应该立即看到。
通知时间：一个进程需要向一个进程或一组进程发送消息，通知他们发生了某种事件（如进程终止时要通知父进程）。
资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供锁和同步机制。
进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道他的状态变化。

进程通信的方式

信号量：

什么是信号量

信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享内存时，其他进程也访问该资源。因此，它主要作为进程间以及同一进程内不同线程之间的同步手段。

信号量是是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行的等待（即P(信号变量））和发送（即V（信号变量））信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量称为通用信号量。

信号量的工作原理

假设有信号量SV，则对它的P、V操作含义如下：

P（SV），如果SV的值大于0，就将它减1；如果SV的值为0，则挂起进程的执行。
V（SV），如果有其他进程因为等待SV而挂起，则唤醒之；如果没有，则将SV加1。

Linux信号量

Linux信号量的API都定义在sys/sem.h头文件中，主要包括三个系统调用：semget、semop和semctl。它们都被设计为操作一组信号量，即信号量集，而不是单个信号量。

semget系统调用

semget系统调用创建一个新的信号量集，或者获取一个已经存在的信号量集。其定义如下：

#include <sys/sem.h>

int semget(key_t key,int num_sems,int sem_flags);

key参数是一个键值，用来标识一个全局唯一的信号量集，就像文件名全局唯一的标识一个文件一样。要通过信号量通信的进程需要使用相同的键值来创建/获取该信号量。

nun_sems参数指定要创建/获取的信号量集中信号量的数目。如果是创建信号量，则该值必须被指定；如果是获取已经存在的信号量，则可以把它设置为0。

sem_flags参数指定一组标志。它低端的9个比特是该信号量的权限。它还可以和IPC_CREAT标志做按位“或”运算以创建新的信号量集。此时即使信号量已经存在，semget也不会产生错误。我们还可以联合使用IPC_CREAT和IPC_EXCL标志来确保创建一组新的、唯一的信号量集。在这种情况下，如果信号量集已经存在，则semget返回错误并设置error为EEXIST。

semget成功时返回一个正整数值，它是信号量集的标识符；semget失败时返回-1，并设置errno。

如果semget用于创建信号量集，则与之关联的内核数据结构体semid_ds将被创建并初始化。semid_ds结构体定义如下：

#include <sys/sem.h>
/*该结构体用来描述IPC对象（信号量、共享内存和消息队列）的权限*/
struct ipc_perm
{
    key_t key;          //键值
    uid_t uid;          //所有者的有效用户ID
    gid_t gid;          //所有者的有效组ID
    uid_t cuid;         //创建者的有效用户ID
    gid_t cgid;         //创建者的有效组ID
    mode_t mode;        //访问权限
                        //省略其他填充字段
}

struct semid_ds
{
    struct ipc_perm sem_perm;      //信号量的操作权限
    unsigned long int sem_nsems;    //该信号量集中信号量的数目；
    time_t sem_otime;              //最后一次调用semop的时间；
    time_t sem_ctime;              //最后一次调用semctl的时间
                                   //省略其他填充字段
}

semget对semid_ds的初始化包括：

将sem_perm.cuid和sem_perm.uid设置为调用进程的有效用户ID。
将sem_perm.cgid和sem_perm.gid设置为调用进程的有效组ID。
将sem_perm.mode的最低9位设置为sem_flags参数的最低9位。
将sem_nsems设置为num_sems。
将sem_otime设置为0。
将sem_ctime设置为当前系统时间。

semop系统调用

semop系统调用改变信号量的值，即P、V操作。在介绍semop之前，需要先介绍每个信号量关联的一些重要的内核变量：

unsigned short semval; //信号量的值

unsigned short semzcnt; //等待信号量变为0的进程的数量

unsigned short semncnt; //等待信号量值增加的进程数量

pid_t semop; //最后一次执行semop操作的进程的ID

semop对信号量的操作实际上就是对这些内核变量的操作。semop的定义如下：

#include <sys/sem.h>

int semop(int sem_id,struct sembuf* sem_ops,size_t num_sem_ops);

sem_id参数是由semget调用返回的信号量集标识符，用以指定被操作的目标信号量集。

sem_ops参数指向一个sembuf结构体类型数组，sembuf结构体的定义如下：

struct sembuf
{
    unsigned short int sem_num;
    short int sem_op;
    short int sem_flg;
}

其中sem_num成员是信号量集中信号量的编号，0表示信号量集中的第一个信号量。

sem_op成员指定操作类型，其可选值为正整数、0、负整数。每种类型的操作的行为又受到sem_flg成员的影响。sem_flg的可选值是IPC_NOWAIT和SEM_UNDO。IPC_NOWAIT的含义是，无论信号量操作是否成功，semop调用都将立即返回，这类似于非阻塞I/O操作。SEM_UNDO的含义是，当进程退出时取消正在进行的semop操作。

semop系统调用的第3个参数num_sem_ops指定要执行的操作个数，即sem_ops数组中元素的个数。semop对数组sem_ops中每个成员按照数组顺序依次执行操作，并且该过程是原子操作，以避免别的进程在同一时刻按照不同的顺序对该信号集中的信号量执行semop操作导致的竞态条件。

semop成功返回0，失败则返回-1并设置error。失败的时候，sem_ops数组中指定的所有操作都不被执行。

semctl系统调用

semctl系统调用允许调用者对信号量进行直接控制。其定义如下：

#include <sys/sem.h>

int semctl(int sem_id,int sem_num,int command,...);

sem_id参数是由semget调用返回的信号量集标识符，用以指定被操作的信号量集。sem_num参数指定被操作的信号量在信号量集中的编号。command参数指定要执行的命令。有的命令需要调用者传递第4个参数。第4个参数的类型由用户自己定义，但sys/sem.h头文件给出了它的推荐格式，具体如下：

union semun
{
    int val;                     //用于SETVAL命令
    struct semid_ds* buf;        //用于IPC_IPC_STAT和IPC_SET命令
    unsigned short* array;       //用于GETALL和SETALL命令
    struct seminfo* _buf;        //用于IPC_INFO命令
};

struct seminfo
{
    int semmap;                  //Linux内核没有使用
    int semmni;                  //系统最多拥有的信号量集数目
    int semmns;                  //系统最多拥有的信号量数目
    int semmnu;                  //Linux内核没有使用
    int semmsl;                  //一个信号量集最多允许包含的信号量数目
    int semopm;                  //semop一次最多能执行的sem_op操作数目
    int semume;                  //Linux内核没有使用
    int semusz;                  //sem_undo结构体大小
    int semvmx;                  //最大允许的信号量值
    //最多允许的UNDO次数(带SEM_UNDO标志的semop操作的次数)
    int semaem;
};

semctl成功时的返回值取决于command参数，如表。semctl失败时返回-1，并设置errno。

管道

管道能在父进程、子进程间传递数据，利用的是fork调用之后两个管道文件描述符（fd[0]和fd[1]）都保持打开。一对这样的文件描述符只能保证父、子进程间一个方向的数据传输，父进程和子进程必须有一个关闭fd[0]，另一个关闭fd[1]。比如，我们要使用管道实现从父进程向子进程写数据，就应该进行如下操作：

显然，如果要实现父、子进程之间的双向数据传输，就必须使用两个管道。socket编程接口提供了一个创建全双工管道的系统调用：socketpair。

管道只能用于有关联的两个进程（比如父、子进程）间的通信。

共享内存

共享内存是最高效的IPC机制，因为它不涉及进程之间的任何数据传输。这种高效率带来的问题是，我们必须使用其他辅助手段来同步进程对共享内存的访问，否则会产生竞态条件。因此，共享内存通常和其他进程间通信一起使用

Linux共享内存的API都定义在sys/sem.h头文件中，包括4个系统调用：shmget、shmat、shmdt和shmctl。

shmget系统调用

shmget系统调用创建一段新的共享内存，或则获取一段已经存在的共享内存。定义如下：

#include <sys/sem.h>

int shmget(key_t key,size_t size,int shmflg);

和semget系统调用一样，key参数是一个键值，用来标识一段全局唯一的共享内存。size参数指定共享内存的大小，单位是字节。如果是创建新的共享内存，则size值必须被指定。如果是获取已经存在的共享内存，则可以吧size设置为0。

shmflg参数的使用和含义与semget系统调用的sem_flags参数相同。不过shmget支持两个额外的标志——SHM_HUGETLB和SHM_NORESERVE。

shmget成功时返回一个正整数值，他是共享内存的标识符。shmget失败时返回-1，并设置errno。

如果shmget用于创建共享内存，则这段共享内存的所有字节都被初始化为0，与之关联的内核数据结构shmid_ds将被创建并初始化。shmid_ds结构体的定义如下：

struct shmid_ds
{
    struct ipc_perm shm_perm;    //共享内存的操作权限
    size_t shm_segsz;            //共享内存大小，单位字节
    _time_t shm_atime;           //对这段内存最后一次调用shmat的时间
    _time_t shm_dtime;           //对这段内存最后一次调用shmdt的时间
    _time_t shm_ctime;           //对这段内存最后一次调用shmctl的时间
    _pid_t shm_cpid;             //创建者的PID
    _pid_t shm_lpid;             //最后一次执行shmat或shmdt操作的进程的PID
    shmatt_t shm_nattach;        //目前关联到此共享内存的进程数量
    //省略一些填充字段
};

shmget对shmid_ds结构体的初始化包括：

将shm_perm.cuid和shm_perm.uid设置为调用进程的有效用户ID。
将shm_perm.cgid和shm_perm.gid设置为调用进程的有效组ID。
将shm_perm.mode的最低9位设置为shmflg参数的最低9位。
将shm_segsz设置为size。
将shm_lpid、shm_nattach、shm_atime、shm_dtime设置为0。
将shm_ctime设置为当前的时间。

shmat和shmdt系统调用

共享内存被创建/获取之后，我们不能立即访问它，而是需要先将它关联到进程的地址空间。使用完共享内存之后，我们也需要将他从进程地址空间中分离。这两项任务分别由如下两个系统调用实现：

#include<sys/sem.h>

void* shmat(int shm_id,const void* shm_addr,int shmflg);

int shmdt(const void* shm_addr);

其中，shm_id参数是由shmget调用返回的共享内存标识符。shm_addr参数指定将共享内存关联到进程的哪块地址空间，最终的效果还受到shmflg参数的可选标志SHM_RND的影响：

如果shm_addr为NULL，则被关联的地址由操作系统选择。这是推荐的做法，以确保代码的可移植性。
如果shm_addr非空，并且SHM_RND标志未被设置，则共享内存被关联到addr指定的地址处。
如果shm_addr非空，并且设置了SHM_RND标志，则被关联的地址是[shm_addr-(shm_addr%SHMLBA)]。SHMLBA的含义是“段低端边界地址倍数”，它必须是内存页面大小的整数倍。现在的Linux内核中，他等于一个内存页的大小。SHM_RND的含义是圆整，即将共享内存被关联的地址向下圆整到离shm_addr最近的SHMLBA的整数倍地址处。

除了SHM_RND标志外，shmflg参数还支持如下标志：

SHM_RDONLY。进程仅能读取共享内存中的内容。若没有指定该标志，则进程可同时对共享内存进行读写操作（当然，这需要在创建共享内存的时候指定其读写权限）。
SHM_REMAP。如果地址shmaddr已经被关联到一段共享内存上，则重新关联。
SHM_EXEC。它指定对共享内存段的执行权限。对共享内存而言，执行权限实际上和读权限是一样的。

shmat成功时返回共享内存被关联到的地址，失败则返回(void*)-1并设置errno。shmat成功时，将修改内核数据shmid_ds的部分字段，如下：

将shm_nattach加1。
将shm_lpid设置为调用进程的PID。
将shm_atime设置为当前的时间。

shmdt函数将关联到shm_addr处的共享内存从进程中分离。它成功时返回0，失败则返回-1并设置errno。shmdt在成功调用时将修改内核数据shmid_ds的部分字段，如下：

将shm_nattach减1。
将shm_lpid设置为调用进程的PID。
将shm_dtime设置为当前的时间。

shmctl系统调用

shmctl系统调用控制共享内存的某些属性。其定义如下：

#include <sys/sem.h>

int shmctl(int shm_id,int command,struct shmid_ds* buf);

其中，shm_id参数是由shmget调用返回的共享内存标识符。command参数指定要执行的命令。shmctl支持的所有命令如表所示：

shmctl成功时的返回值取决于command参数。shmctl失败时返回-1，并设置errno。

消息队列

消息队列是在两个进程之间传递的二进制块数据的一种简单有效的方式。每个数据块都有一个特定的类型，接收方可以根据类型来有选择地接收数据，而不一定像普通管道和命名管道那样必须以先进先出的方式接收数据。

Linux消息队列的API都定义在sys/msg.h头文件中，包括4个系统调用：msgget、msgsnd、msgrcv和msgctl。

msgget系统调用

msgget系统调用创建一个消息队列，或者获取一个已有的消息队列。其定义如下：

#include <sys/msg.h>

int msgget(key_t key,int msgflg);

和semget系统调用一样，key参数是一个键值，用来标识一个全局唯一的消息队列。

msgflg参数的使用和含义与semget系统调用的sem_flags参数相同。

msgget 成功时返回一个正整数值，它是消息队列的标识符。msgget失败时返回-1，并设置errno。

如果msgget用于创建消息队列，则与之关联的内核数据结构msqid_ds将被创建并初始化。msqid_ds数据结构的定义如下：

struct msqid_ds
{
    struct ipc_perm msg_perm;        //消息队列的操作权限
    time_t msg_stime;                //最后一次调用msgsnd的时间
    time_t msg_rtime;                //最后一次调用msgrcv的时间
    time_t msg_ctime;                //最后一次被修改的时间
    unsigned long _msg_cbytes;       //消息队列中已有的字节数
    msgqnum_t msg_qnum;              //消息队列中已有的消息数
    msglen_t msg_qbytes;             //消息队列允许的最大字节数
    pid_t msg_lspid;                 //最后执行msgsnd的进程的PID
    pid_t msg_lrpid;                 //最后执行msgrcv的进程的PID
};

msgsnd系统调用

msgsnd系统调用把一条消息添加到消息队列中。其定义如下：

#include <sys/msg.h>

int msgsnd(int msqid,const void* msg_ptr,size_t msg_sz, int msgflg);

msqid参数是由msgget调用返回的消息队列标识符。

msg_ptr参数指向一个准备发送的消息，消息必须被定义为如下类型：

struct msgbuf
{
    long mtype;         //消息类型
    char mtext[512];    //消息数据
};

其中，mtype成员指定消息的类型，它必须是一个正整数。mtext是消息数据。msg_sz参数是消息的数据部分（mtext）的长度。这个长度可以为0,表示没有消息数据。

msgflg参数控制msgsnd的行为。它通常仅支持IPC_NOWAIT标志，即以非阻塞的方式发送消息。默认情况下，发送消息时如果消息队列满了，则msgsnd将阻塞。若IPC_NOWAIT标志被指定，则msgsnd将立即返回并设置errno为EAGIN。

处于阻塞状态的msgsnd调用可能被如下两种情况所中端：

消息队列被移除。此时msgsnd调用将立即返回并设置errno为EIDRM。
程序接收到信号。此时msgsnd调用将立即返回并设置errno为EINTR。

msgsnd成功时返回0，失败则返回-1并设置errno。msgsnd成功时将修改内核数据结构msqid_ds的部分字段，如下所示：

将msg_qnum加1.
将msg_lspid设置为调用进程的PID。
将msg_stime设置为当前的时间。

msgrcv系统调用

msgrv系统调用从消息队列中获取消息。其定义如下：

#include <sys/msg.h>

int msgrcv(int msqid,void* msg_ptr, size_t msg_sz, long int msgtype,int msgflg);

msqid参数是由msgget调用返回的消息队列标识符。

msg_ptr参数用于存储接收的消息，msg_sz参数指的是消息数据部分的长度。

msgtype参数指定接收何种类型的消息。我们可以使用如下几种方式来指定消息类型：

msgtype等于0.读取消息队列中的第一个消息。
msgtype大于0.读取消息队列中第一个类型为msgtype的消息（除非指定了标志MSG_EXCEPT）。
msgtype小于0.读取消息队列第一个类型值比msgtype的绝对值小的消息。

参数msgflg控制msgrcv函数的行为。它可以是如下一些标志的按位或：

IPC_NOWAIT。如果消息队列中没有消息，则msgrcv调用立即返回并设置errno为ENOMSG。
MSG_EXCEPT。如果msgtype大于0，则接收消息队列中第一个非msgtype类型的消息。
MSG_NOERROR。如果消息数据部分的长度超过了msg_sz，就将它截断。

处于阻塞状态的msgrcv调用还可能被如下两种异常情况所中断：

消息队列被移除。此时msgrcv调用将立即返回并设置errno为EIDRM。
程序接收到信号。此时msgrcv调用将立即返回并设置errno为EINTR。

msgrcv成功时返回0，失败则返回-1并设置errno。msgrcv成功时将修改内核数据结构msqid_ds的部分字段，如下所示：

将msg_qnum减1。
将msg_lrpid设置为调用进程的PID。
将msg_rtime设置为当前的时间。

msgctl系统调用

msgctl系统调用控制消息队列的某些属性。其定义如下：

#include <sys/msg.h>

int msgctl(int msqid,int command,struct msqid_ds*buf);

msqid参数是由msgget调用返回的共享内存标识符，command参数指定要执行的命令。msgctl支持的所有命令如下表。

IPC命令

套接字

1、TCP/IP

在学习socket之前，先简单了解一下TCP/IP协议族，这样更有助于理解socket在网络编程中所处的位置。
TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，定义了主机如何连入因特网及数据如何再它们之间传输的标准，从字面意思来看TCP/IP是TCP和IP协议的合称，但实际上TCP/IP协议是指因特网整个TCP/IP协议族。大学里通信的应该还学过ＯＳＩ模型的七个分层，TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中

应用层：TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet 等等

传输层：TCP，UDP

网络层：IP，ICMP，OSPF，EIGRP，IGMP

数据链路层：SLIP，CSLIP，PPP，MTU

每一抽象层建立在低一层提供的服务上，并且为高一层提供服务，看起来大概是这样子的。

è¿éåå¾çæè¿°

2、Socket

2.1socket在哪里

前面已经简单介绍了tcp/ip，socket又跟tcp/ip有什么关系呢，请看下图

è¿éåå¾çæè¿°

socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用，从而实现进程在网络中通信。

在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。所谓的socket编程，只要熟悉这些接口即可。

2.2什么是socket

Socket的英文原义是“插座”（还有其他含义，但是当初网络变成起名为socket主要是借用了插座的概念）。通常也称作”套接字”，主要用于解决网络进程间通信。

两个进程如果需要进行通讯最基本的一个前提能能够唯一的标示一个进程。本地进程间通信（PIPE、FIFO、message queue、semaphore、shared memary）可以通过进程ID唯一标识一个进程。

网络进程间通信呢？PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标识主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程。

Socket是面向”客户/服务器“（C/S）模型而设计的，针对客户和服务器程序提供不同的Socket系统调用。这种模式巧妙地解决了进程之间建立通信连接的问题。服务器Socket会公告给需要通信的一方。

不妨考虑一下，两个完全随机的用户进程之间如何建立通信？假如通信双方都不知道对方的socket编号，就好比打电话的双方彼此不知道对方的电话号码，要通话是不可能的。采用了C/S模式后，由client端发起请求，server端接收请求，并应答，从而建立好链接。

可以通过下图理解一下socket链接的建立过程

è¿éåå¾çæè¿°

还可以通过一个生活中常见的事情做一个比喻：你要打电话给一个朋友，先拨号（这个号肯定提前已知，在这个例子中，被叫方可以当做server端来理解），朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。

3、Socket编程API

3.1、socket()函数

socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种”打开—读/写—关闭”模式的实现，服务器和客户端各自维护一个”文件”，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。
注：不论是作为客户端还是作为服务器端，都使用该函数创建socket描述符。

int socket(int domain, int type, int protocol);

domain：即协议域，又称为协议族（family）。
　　常用的协议族有AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等（ＡＦ是address family简称）。
　　协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

type：指定socket类型。

常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等。

protocol：故名思意，就是指定协议。

常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。

注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM和SOCK_SEQPACKET是面向链接的类型，因此protocol也应该选择面向链接的tcp协议。当protocol为0时，会自动选择type对应的默认协议。

3.2、bind()函数

正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。
注：该函数只有服务器端才需要调用

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：即socket描述字，是通过socket()函数创建的唯一标识一个socket。bind()函数就是给这个描述字绑定一个名字。

addr：指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是：

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};
ipv6对应的是： 
struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};
Unix域对应的是： 
#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};

addrlen：对应的是地址的长度。
通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来连接服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

3.3、listen()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。
注：该函数只有服务器端才需要调用

int listen(int sockfd, int backlog);

sockfd:即为要监听的socket描述字；

backlog:相应socket可以排队的最大连接个数。

socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的(也就是变成server)，等待客户的连接请求。

3.4、accept()函数

TCP服务器端依次调用socket()、bind()、listen()之后，就可以监听指定的socket地址了。

当客户端通过调用connect()函数发送链接请求后。一旦服务器监听到该请求之后，就会调用accept()函数接收请求，这样连接就建立好了，之后就可以开始网络I/O操作了，类同于普通文件的读写I/O操作。
该函数只有服务器端才需要调用

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockfd：服务器端socket描述字；

addr：客户端的协议地址；客户端请求链接时候，肯定会发送自己的地址，以便服务器端能够知道链接的目的地（参见connect函数参数）；

addrlen：协议地址的长度。

注意：
　　accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。
　　一个服务器通常仅创建一个监听socket描述字，它在该服务器的生命周期内一直存在。
　　而客户端请求的socket链接，则是右内核随机创建的，这个新创建的socket_fd才是服务器端与客户端通信的socket描述符，当服务器完成了对某个客户的服务，对应被创建的socket描述字就被关闭。

3.5、connect()函数

客户端如果想发送链接请求，首先需要调用socket()函数，来创建socket描述符，然后就可以调用connect()函数来向服务器端发送请求。
注：该函数只有客户端端才需要调用

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：客户端的socket描述字；
addr：服务器的socket地址；
**addrlen：**socket地址的长度。

3.6、read()、write()等函数

客户端调用connect()发送链接请求，服务器端监听到该请求，并通过accept(）函数处理，正确建立链接后，那么就可以可以调用网络I/O进行读写操作了，即实现了网络中不同进程之间的通信！

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

ssize_t write(int fd, const void *buf, size_t count);

既然一个套接字端点被表示为一个文件描述符，因此只要建立链接，就可以使用为本地文件设计的read和write函数，如下所示。但是如果想指定更多的选项，如从多个客户端读取消息或发送带外数据等，则read和write无能为力，因此还是建议使用转为socket设计的函数。

#include <sys/types.h>
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

这组函数的前三个参数和read/write参数含义类似，优势是多了一个flags参数，该参数可以指定一些其他动作，如：容许非阻塞操作，发送数据后立刻关闭发送端的socket等，详细可以参考该函数的flags说明。
该组函数，没有指定目的地址，因此只能先建立链接，然后才能发送数据，也即用于面向tcp链接的socket通信。

#include <sys/socket.h>
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

该组函数send时候增加了目的地址，receive时候增加了源地址，支持面向无连接的通讯，即udp。

#include <sys/socket.h>
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

struct msghdr {
void *msg_name; /* ptr to socket address structure */
int msg_namelen; /* size of socket address structure */
struct iov_iter msg_iter; /* data */
void *msg_control; /* ancillary data */
__kernel_size_t msg_controllen; /* ancillary data buffer length */
unsigned int msg_flags; /* flags on received message */
struct kiocb *msg_iocb; /* ptr to iocb for async requests */
};

从msghdr的结构看，该函数功能更强大，socket编程比较倾向与使用这组函数。

3.7、close()函数

在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

#include <unistd.h>

int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

4、其他注意事项

既然是面向不通设备的通信，那么通信过程的编码就必须一致，当前计算机有采用大字节序的也有采用小字节序的，但是在发送消息前，要转换为网络字节序（大字节序），接收消息后，要将消息内容从网络字节序转为本机字节序然后才能解析数据。

参考文献：

《Linux高性能服务器编程》

https://blog.csdn.net/younkerjqb/article/details/53635773

A1ke

关注

3
点赞
踩
34

收藏

觉得还不错? 一键收藏
0
评论
进程间通信的五种方式（信号量，管道，套接字，消息队列，共享内存）

进程的概念进程是操作系统的概念，每当我们执行一个程序时候，对于操作系统来讲就创建了一个进程，在这个过程中，伴随着资源的分配和释放。可以认为进程是一个程序的一次执行过程。进程通信的概念进程用户空间是相互独立的，一般而言是不能相互访问的。但是很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其他进程之间的互相通信来协调他们的行为。进程通信的应用场景数据传输：一个进程需...
复制链接

扫一扫