为什么使用socketserver
虽然Python内置的socket和threading模块能实现简单的多线程服务器，在非正式环境，随便用用还是可以的，但是如果要在生产环境中使用，那是万万不够的。
Python考虑得很周到，为了满足我们对多线程网络服务器的需求，提供了"socketserver"模块。socketserver在内部使用IO多路复用以及多线程/进程机制，实现了并发处理多个客户端请求的socket服务端。每个客户端请求连接到服务器时，socketserver服务端都会创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。
使用socketserver要点
创建一个继承自"socketserver.BaseRequestHandler"的类；
这个类中必须重写一个名字为"handle"的方法，不能是别的名字！
将这个新建的类，连同服务器的IP和端口作为参数传递给"ThreadingTCPServer()"构造；
手动启动"ThreadingTCPServer"。
栗子
服务端
importsocketserver#必须继承socketserver.BaseRequestHandler类
classMySockServer(socketserver.BaseRequestHandler):defhandle(self):#request里封装了所有请求的数据
conn =self.request
conn.sendall(‘欢迎访问socketserver服务器‘.encode())whileTrue:
data= conn.recv(1024).decode()if data == ‘exit‘:print(‘断开与%s的连接！‘ % (self.client_address,))  #注意是元组！
break
elifdata:print(‘来自%s客户端向你发来数据：%s‘ %(self.client_address, data))
conn.sendall(‘服务器已收到数据‘.encode())if __name__ == ‘__main__‘:#创建一个多线程TCP服务器
sock_server = socketserver.ThreadingTCPServer((‘127.0.0.1‘, 8888), MySockServer)print(‘启动服务器！‘)#启动服务器，服务器将一直保持运行状态
sock_server.serve_forever()
分析一下服务器端的代码，核心要点有这些：
连接数据封装在"self.request"属性中！通过"self.request"对象调用"send()"和"recv()"方法。
"handle()"方法是整个通信的处理核心，一旦它运行结束，当前连接也就断开了(但其他的线程和客户端还正常)，因此一般在此设置一个无限循环。
注意"sock_server = socketserver.ThreadingTCPServer((‘127.0.0.1‘, 8888), MySockServer)"中参数传递的方法。
"sock_server.serve_forever()"表示该服务器在正常情况下将永远运行。
客户端
importsocket#客户端依然使用socket模块就可以了，不需要导入socketserver模块
IP_PORT= (‘127.0.0.1‘, 8888)
sock=socket.socket()
sock.connect(IP_PORT)
sock.settimeout(0.5)
data= sock.recv(1024).decode()print(‘接收返回数据：%s‘ %data)whileTrue:
inp= input(‘输入要发送的数据：‘).strip()if notinp:continuesock.sendall(inp.encode())if inp == ‘exit‘:print(‘谢谢使用，再见！‘)breakdata= sock.recv(1024).decode()print(‘接收返回数据：%s‘ %data)
sock.close()
客户端的代码很好理解，依然使用socket模块就可以了，不需要导入socketserver模块。
至此。

附加：进程通信-实验3：网络套接字通信
一．实验目的

·理解并掌握网络套接字通信的原理和使用方法。

二．实验背景

·什么是套接字（socket）

·socket可以看作进程访问系统网络组件的接口，它有相应的一块内存，其中存放了它的各种属性。进程对socket的各种操作将转换为对网络组件的操作，从而通过网络收发数据。当属于不同进程的两个套接字之间建立了一个连接，那么，这两个进程就可以通过这一对套接字进行通信了。一个进程可以创建多个套接字，分别用于不同的通信目的。一个通信连接关联一对且只能是一对套接字。


·套接字不仅可用于本地通信，更可以用于网络通信


·客户/服务器模型（Client/Server）

在进行通信的两个进程中，主动发起通信请求的一方称为客户，被动响应的一方称为服务器。它们既可以是处在同一台计算机上的两个进程，也可以分别处于网络环境下的不同主机上。这种通信模型叫作客户/服务器模型，即Client/Server模型（简称C/S模型），是所有网络应用的基础。


·服务器实现

第1步：创建套接字

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

socket函数创建一个套接字，并返回一个套接字描述符，用于将来访问该套接字。

domain参数是套接字的域（协议族），最常用的域是AF_UNIX和AF_INET，前者用于通过Linux文件系统实现本地套接字，后者用于实现网络套接字。

type指定套接字类型，决定了套接字所采用的通信机制。有两种常见类型：流套接字和数据报套接字。

protocol指定通信所用的协议，一般由套接字域和类型来决定，一般将其设为0，表示使用默认协议。

第2步：为套接字命名

int bind(int socket, const struct sockaddr *address, size_t address_len);

所谓命名（naming），其实就是将套接字绑定（binding）到一个特定的地址。对于AF_UNIX套接字，就是将套接字关联到文件系统的一个路径名，而对于AF_INET套接字是关联到一个IP端口号。

第3步：监听连接

int listen(int socket, int backlog);

Listen函数在服务套接字上监听客户端连接，它会创建一个队列来缓存未处理的连接；

其中，socket是服务套接字的标识符。backlog为连接队列的最大长度。

第4步：接受连接

int accept(int socket, struct sockaddr *address, size_t *address_len);

accept函数会创建一个新套接字来与所接受的客户进行通信，并返回新套接字的描述符。


·客户端实现

第1步：创建无名套接字

int sock = socket(AF_UNIX, SOCK_STREAM, 0);

这里创建一个客户端套接字，对客户端套接字来说是无需命名的。

第2步：请求连接服务器

int connect(int socket, const struct sockaddr *address, size_t address_len);

该函数在一个未命名的客户套接字和服务器套接字之间建立一个连接。

第3步：数据通信

连接一旦建立起来，就可以用连接所关联的一对套接字进行双向数据通信了,方法是向套接字读写数据。例如：

int a=100,b=200,c=0;

write(sock, &a, sizeof(int));

write(sock, &b, sizeof(int));

read(sock, &c, sizeof(int));

第4步：关闭套接字

int close(int socket);

三．关键代码及分析
 /* 创建套节字 */
    int server_sock = socket(AF_INET, SOCK_STREAM, 0);

    /* 为套节字命名 */
    struct sockaddr_in server_address;
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr =inet_addr("127.0.0.1");  //或赋值为 htonl(INADDR_ANY)
    server_address.sin_port = htons(7000);
    int server_len = sizeof(server_address);

    bind(server_sock, (struct sockaddr *)&server_address, server_len);

    /* 监听客户的连接请求（创建一个连接队列，等待客户的连接） */
    listen(server_sock, 5);
    
    /* 接受连接 */
    int client_sock, client_len;
    struct sockaddr_in client_address;
    int a,b,c;
    while(1) {
        printf("server waiting\n");
        /* 接受一个连接（创建一个新套节字client_sockfd，用于与接受的这个客户进行通信） */
        client_len = sizeof(client_address);
        client_sock = accept(server_sock, (struct sockaddr *)&client_address, &client_len);

        /* 通过对client_sockfd套节字的读写操作与客户进行通信　*/
        read(client_sock, &a, sizeof(int));
        read(client_sock, &b, sizeof(int));
        c=a+b;
        write(client_sock, &c, sizeof(int));
        close(client_sock);
}

/* 创建套节字 */
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    /* 将该套节字连接到服务器套节字 */
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("127.0.0.1");
    address.sin_port = htons(7000);
    int len = sizeof(address);

    int result = connect(sock, (struct sockaddr *)&address, len);
    if(result == -1) {
        perror("连接服务器失败");
        exit(1);
    }

    /* 通过该套节字读写数据 */
    int a=100,b=200,c=0;
    write(sock, &a, sizeof(int));
    write(sock, &b, sizeof(int));
    read(sock, &c, sizeof(int));
    printf("来自服务器的数据为： %d\n", c);

    /* 关闭套接字 */
    close(sock);
    exit(0);

三．实验结果与分析
·   //编译连接生成可执行程序

gcc -o sockFileServer sockFileServer.c

gcc -o sockFileClient sockFileClient.c



·	//执行生产的可执行程序

./sockFileServer &

./sockFileClient

常见的网络通信模型都会使用IO多路复用技术如select、poll、epoll等。当有新的连接请求到来时，监听套接字变为可读，然后调用accept()接收新连接、返回一个连接套接字。
如果监听套接字是阻塞的，问题可能出在什么地方？
先来看下TCP三次握手的示意图：



从图中可知，connect()会先于accep()函数返回。
当一个连接到来的时候，监听套接字可读，此时，我们稍微等一段时间之后再调用accept()。就在这段时间内，客户端设置linger选项(l_onoff = 1, l_linger = 0)，然后调用了close()，那么客户端将不经过四次挥手过程，通过发送RST报文断开连接。服务端接收到RST报文，系统会将排队的这个未完成连接直接删除，此时就相当于没有任何的连接请求到来， 而接着调用的accept()将会被阻塞，直到另外的新连接到来时才会返回。这是与IO多路复用的思想相违背的(系统不阻塞在某个具体的IO操作上，而是阻塞在select、poll、epoll这些IO复用上的)。
上述这种情况下，如果监听套接字为非阻塞的，accept()不会阻塞住，立即返回-1，同时errno = EWOULDBLOCK。
具体示例可参考UNP 16.6节 非阻塞accept。

应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要 通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了称为套接字 (Socket)的接口，区分不同应用程序进程间的网络通信和连接。

生成套接字，主要有3个参数：通信的目的IP地址、使用的传输 层协议(TCP或UDP)和使用的端口号。Socket原意是“插座”。通过将这3个参数结合起来，与一个“插座”Socket绑定，应用层就可以和传输 层通过套接字接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。

 

Socket可以看成在两个程序进行通讯连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中。如图1：



Host A上的程序A将一段信息写入Socket中，Socket的内容被Host A的网络管理软件访问，并将这段信息通过Host A的网络接口卡发送到Host B，Host B的网络接口卡接收到这段信息后，传送给Host B的网络管理软件，网络管理软件将这段信息保存在Host B的Socket中，然后程序B才能在Socket中阅读这段信息。

 

要通过互联网进行通信，至少需要一对套接字，一个运行于客户机端，称之为ClientSocket，另一个运行于服务器端，称之为serverSocket。     

根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。     

服务器监听：是服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。

客户端请求：是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

连 接确认：是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客 户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

socket通信流程：



1、服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket

2、服务器为socket绑定ip地址和端口号

3、服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开

4、客户端创建socket

5、客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket

6、服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直到客户端返回连接信息后才返回，开始接收下一个客户端谅解请求

7、客户端连接成功，向服务器发送连接状态信息

8、服务器accept方法返回，连接成功

9、客户端向socket写入信息

10、服务器读取信息

11、客户端关闭

12、服务器端关闭