python socket通信原理_Python-面向网络编程-socket原理

socket

整个计算机网络是由协议构成，想要通信必须遵守对应的协议，如Web中的http协议、传输协议TCP和UDP等等。在网络工程师的眼中，可能现在网络上的一切都是socket，一切皆socket，我们一般接触到的是应用层应用程序，本质上两个应用想通信，则必须通过socket实现通信，socket直接和传输层后下面的底层网络协议打交道(socket本身让我们直接与TCP打交道)，底层socket已经建立好则可以互相通信。互联网现在主流的网络层协议是IPv4，IPv6是下一代网络层协议但不主流，IPv6解决的是IPv4地址耗尽的问题，其实为了应对IPv4资源少的问题产生了局域网和网关。

网络模型

其发展过程，是一次解决需求的迭代过程。当计算机刚发明并投入使用，两台计算机想实现点对点通信，于是产生了数据链路层，当加入更多的计算机实现通信的时候，就产生了网络层，实现通信还不能满足需求，需要通过网络传输数据，则产生了传输层，对于可靠性的需求产生了TCP和UDP两种传输协议，不同的用户有不同的需求，于是应用层就被划分出来了。用户在应用层使用各种app，数据依次往下组包直至物理层发送到网络，接收数据则往上拆包得到最终数据。本质上是需求推动了网络层次的产生，当前把网络七层模型中的会话、表示、应用层统称为应用层。

应用层 　　　　 文件传输、文件服务、电子邮件 http ftp smtp dns

传输层　　　　通过端对端的接口TCP UDP

网络层　　　　为数据包选择路由IP ICMP

数据链路层　　  传输有地址的帧、错误检测功能ARP

物理层　　　　物理媒体

北门吹雪：http://www.cnblogs.com/2bjiujiu/

一般建立在socket上通信的应用都采用C/S模型，这里来理清C/S架构

客户端：

需要申明协议、请求建立连接、发送和接收数据、关闭连接这些过程

服务端：

申明协议实例监听者(来源三体)、绑定监听IP和端口、启动监听者监听、建立连接、接收和发送数据、断开连接这些过程

# 下面这个是单线程服务端监听者实例过程

客户端实例实现过程

import socket

import time

def beimenchuixue_client():

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect(('127.0.0.1', 8000))

while True:

data = input("北门吹雪:")

if not data.strip():

continue

client.send(data.encode('utf-8'))

response = client.recv(1024)

print(response.decode('utf-8'))

if __name__ == '__main__':

print("北门吹雪: http://www.cnblogs.com/2bjiujiu/")

while True:

# 一个小重启

try:

beimenchuixue_client()

except ConnectionResetError as e:

time.sleep(2)

单线程客户端监听者实例实现过程

import socket

def beimenchuixue_alone_socket():

listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

listener.bind(('0.0.0.0', 8000))

listener.listen()

while True:

conn, remote_address = listener.accept()

print("%s:%s 建立连接" % remote_address)

while True:

# 处理客户端端口异常

try:

data = conn.recv(1024).decode("utf-8")

except ConnectionResetError as e:

print("%s:%s 断开连接" % remote_address)

conn.close()

break

conn.send(bytes(data.upper(), encoding='utf-8'))

if __name__ == '__main__':

print("北门吹雪: http://www.cnblogs.com/2bjiujiu/")

beimenchuixue_alone_socket()

#  这个服务端实现了把小写转换为大写的服务，其他客户端连接来需要排队等待正在处理的客户端断开请求，也就是其他客户端进入堵塞状态

北门吹雪：http://www.cnblogs.com/2bjiujiu/

多线程或协程处理连接请求架构图

线程处理连接架构图

多线程客户端监听者实例实现过程

import socket

from threading import Thread

def beimenchuixue_handler(conn, remote_address):

"""线程处理处理每个连接"""

# 处理客户端断开异常

while True:

try:

data = conn.recv(1024).decode("utf-8")

except ConnectionResetError as e:

print("%s:%s 断开连接" % remote_address)

break

conn.send(bytes(data.upper(), encoding='utf-8'))

conn.close()

def beimenchuixue_socket():

listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

listener.bind(('0.0.0.0', 8000))

listener.listen()

while True:

conn, remote_address = listener.accept()

print("%s:%s 建立连接" % remote_address)

handler = Thread(target=beimenchuixue_handler, args=(conn, remote_address))

handler.start()

if __name__ == '__main__':

print("北门吹雪: http://www.cnblogs.com/2bjiujiu/")

beimenchuixue_socket()

面向对象方式写多线程socket

import socket

from threading import Thread

class BeiMenChuiXueHandle(Thread):

def __init__(self, conn, remote_address):

super().__init__()

self.conn = conn

self.remote_address = remote_address

def run(self):

while True:

try:

data = self.conn.recv(1024).decode("utf-8")

except ConnectionResetError as e:

print("北门吹雪")

print("%s:%s 断开连接" % self.remote_address)

break

self.conn.send(bytes(data.upper(), encoding='utf-8'))

self.conn.close()

class BeiMenChuiXueHandleSocket:

def __init__(self):

self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

def _handle(self, conn, remote_address):

handler = BeiMenChuiXueHandle(conn, remote_address)

handler.start()

def socket_run(self, ip, port):

self.listener.bind((ip, port))

self.listener.listen()

while True:

conn, remote_address = self.listener.accept()

print("北门吹雪")

print("%s:%s 建立连接" % remote_address)

self._handle(conn, remote_address)

if __name__ == '__main__':

listener = BeiMenChuiXueHandleSocket()

listener.socket_run(ip='0.0.0.0', port=8000)

协程方式写socket(需要安装协程模块gevent，在Python3.5版本中本身就支持协程语义async await)

import socket

import gevent

from gevent import monkey

class BeiMenChuiXueSocket:

def __init__(self, ip, port):

# 自动标记堵塞，要放到所有堵塞实例之前

monkey.patch_all()

self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

self.ip = ip

self.port = port

def _handler(self, conn, remote_address):

while True:

try:

data = conn.recv(1024).decode("utf-8")

except ConnectionResetError as e:

print("北门吹雪")

print("%s:%s 断开连接" % remote_address)

break

conn.send(bytes(data.upper(), encoding='utf-8'))

conn.close()

def forever_run(self):

self.listener.bind((self.ip, self.port))

self.listener.listen()

while True:

conn, remote_address = self.listener.accept()

print("北门吹雪")

print("%s:%s 建立连接" % remote_address)

# 启动协程处理连接

gevent.spawn(self._handler, conn, remote_address)

if __name__ == '__main__':

beimenchuixue = BeiMenChuiXueSocket('0.0.0.0', 8000)

beimenchuixue.forever_run()

经验：

1. socket是网络最为基础的通信方式，也是上层应用的通信基础

2. 服务端为了同时响应多个请求则可以选择进程、线程、协程等多种方式处理连接进来的请求，一般选择线程或协程

3. CPython由于GIL保证一颗核只能在同一时刻跑一个线程，多进程在某种意义上只是开启了多个线程，而进程开销这么大，不是好方法，也就是说对Python的异步编程还是要使用线程或者协程进行

4. Python线程、协程只适于IO密集型，不适用CPU密集型，由于GIL的存在本质上是个单线程