socket编程

什么是 socket 编程

视频讲解

白月黑羽教Python学习视频 - 什么是 socket 编程



白月黑羽写本文的时候是2019年,现在的软件开发基本都需要 网络通讯

不管是传统计算机软件,还是手机软件,还是物联网嵌入系统软件,这些都要和其他网络系统进行通讯。

而当今网络世界 基本上 都是使用TCP/IP协议进行通讯的。

任何应用,比如 浏览网页、微信、支付宝、抖音 或者我们开发的 等等都是 通过TCP/IP协议进行通讯的。

TCP/IP 协议 就是一种传输 数据的 方案。

我们可以用 发快递 打比方。

在南京的白月 要寄一个 物品 给 在北京的黑羽。

选择一个快递公司,就是选择了一种 传输物品的 规范。 因为不同的快递公司 传输物品的具体方案不同。

白月 作为一个 寄件人, 他 不需要知道 快递公司 传输物品的方案的 所有细节

他只要知道 如何把 物品 给快递公司上门的收件人,就行了。

黑羽 作为一个收件人, 他也 不需要知道 快递公司 传输物品的方案的所有细节。

他只要知道,如何从快递公司的收件人 收物品 就行了。


对应到 软件开发上,

收发信息的 程序进程 就像 发件人 和 收件人

收发的 信息 就像 快递传输的 物品

具体信息的传输路径(中间经过哪些路由器)和传输的方法(使用什么协议)就像 快递公司的运输流程;

同样的,我们编写 发出信息的程序和接收信息的程序,并不需要知道 信息传输的所有细节,比如 中间经过哪些路由器,路由器之间又是如何传输的。


我们作为程序员,只要知道,我们的程序如何把 所要发送的信息 交给 ‘收件人’, 如何从 ‘送件人’ 手中获取信息。

那么 和我们的 应用程序 直接打交道的 ‘收件人’ 和 ‘送件人’ 到底是谁?

就是操作系统 提供的 socket 编程接口

发送信息的应用程序,通过 socket 编程接口 把信息给操作系统的TCP/IP协议栈通讯模块;

通讯模块一层层传递给 其他通讯模块(网卡驱动等),最后再通过网卡等硬件设备发送到网络上去;

经过 网络上路由器的一次次转发,最终到了 目的程序 所在的 计算机(或者手机等设备) , 再通过 其 操作系统的 TCP/IP协议栈通讯模块 一层层上传。

最后接收信息的程序,通过 socket 编程接口 接收到了 传输的信息。

这个过程可以用下图来表示

白月黑羽Python3教程


我们前面使用过 requests库 发送 HTTP请求消息,其实 requests库底层也是使用的socket编程接口发送HTTP请求消息。

HTTP 传输的消息 底层也是通过 TCP/IP 协议 传输的, HTTP 加上了一些额外的规定, 比如传输消息的格式。

就像我们发快递的时候做了些额外的处理。比如 把物品 放到一个盒子里。


Python 语言中socket编程

要进行socket编程,发送网络消息,我们可以使用 Python 内置的 socket 库 。


目前的socket编程,使用的最多的就是通过tcp协议进行网络通讯的。

tcp进行通讯的程序双方,分为服务端和客户端。

tcp 协议进行通讯的双方,是需要先建立一个虚拟连接的。然后双方程序才能发送业务数据信息。

建立tcp虚拟连接是通过著名的 三次握手 进行的。

具体三次握手的细节大家可以参考这篇文章 https://zhuanlan.zhihu.com/p/40499563


我们现在来看一个 tcp协议进行通讯的 socket 服务端程序和客户端程序。


下面是tcp 服务端程序 server.py

#  === TCP 服务端程序 server.py ===

# 导入socket 库
from socket import *

# 主机地址为空字符串,表示绑定本机所有网络接口ip地址
# 等待客户端来连接
IP = ''
# 端口号
PORT = 50000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512

# 实例化一个socket对象
# 参数 AF_INET 表示该socket网络层使用IP协议
# 参数 SOCK_STREAM 表示该socket传输层使用tcp协议
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))


# 使socket处于监听状态,等待客户端的连接请求
# 参数 8 表示 最多接受多少个等待连接的客户端
listenSocket.listen(8)
print(f'服务端启动成功,在{PORT}端口等待客户端连接...')

dataSocket, addr = listenSocket.accept()
print('接受一个客户端连接:', addr)

while True:
    # 尝试读取对方发送的消息
    # BUFLEN 指定从接收缓冲里最多读取多少字节
    recved = dataSocket.recv(BUFLEN)

    # 如果返回空bytes,表示对方关闭了连接
    # 退出循环,结束消息收发
    if not recved:
        break

    # 读取的字节数据是bytes类型,需要解码为字符串
    info = recved.decode()
    print(f'收到对方信息: {info}')

    # 发送的数据类型必须是bytes,所以要编码
    dataSocket.send(f'服务端接收到了信息 {info}'.encode())

# 服务端也调用close()关闭socket
dataSocket.close()
listenSocket.close()


下面是tcp 客户端程序 client.py

#  === TCP 客户端程序 client.py ===

from socket import *

IP = '127.0.0.1'
SERVER_PORT = 50000
BUFLEN = 1024

# 实例化一个socket对象,指明协议
dataSocket = socket(AF_INET, SOCK_STREAM)

# 连接服务端socket
dataSocket.connect((IP, SERVER_PORT))

while True:
    # 从终端读入用户输入的字符串
    toSend = input('>>> ')
    if  toSend =='exit':
        break
    # 发送消息,也要编码为 bytes
    dataSocket.send(toSend.encode())

    # 等待接收服务端的消息
    recved = dataSocket.recv(BUFLEN)
    # 如果返回空bytes,表示对方关闭了连接
    if not recved:
        break
    # 打印读取的信息
    print(recved.decode())

dataSocket.close()

大家保存一下代码运行一遍看看。

注意,要先运行服务段,再运行客户段。

上面代码的细节,请看如下视频讲解

视频讲解


白月黑羽教Python学习视频 - socket编程-1

支持多个客户端

上面的服务端代码 只能和一个客户端进行通信。

如果我们同时运行多个客户端,就会发现 后面的客户端程序不能和服务端连接成功。为什么呢?

因为,服务端程序必须不停的对 监听 socket 对象调用 accept()方法,才能不断的接受 新的客户端连接请求。

而且 还需要运行额外的代码 对 多个客户端连接后,返回的多个数据传输socket对象 进行数据的收发。

显然,我们上面的程序没有这样的处理。

因为缺省情况创建的 socket 是 阻塞式 的,进行 accpet调用时,如果没有客户端连接,程序就阻塞在此处,不再执行后续代码。

同样的,调用recv方法,如果没有数据在本socket的接收缓冲,也会阻塞。

所以,通常一个线程里面,没法 不断地 调用 监听socket的 accept方法,同时还能 负责多个 数据传输socket消息的收发。

那么让一个服务端程序 和多个客户端同时连接 并 通信 呢?

聪明的你一定想到了,一个线程不行,就使用多个线程啊。

我们 修改服务端的代码,如下

#  === TCP 服务端程序 server.py , 支持多客户端 ===

# 导入socket 库
from socket import *
from threading import Thread

IP = ''
PORT = 50000
BUFLEN = 512

# 这是新线程执行的函数,每个线程负责和一个客户端进行通信
def clientHandler(dataSocket,addr):
    while True:
        recved = dataSocket.recv(BUFLEN)
        # 当对方关闭连接的时候,返回空字符串
        if not recved:
            print(f'客户端{addr} 关闭了连接' )
            break

        # 读取的字节数据是bytes类型,需要解码为字符串
        info = recved.decode()
        print(f'收到{addr}信息: {info}')

        dataSocket.send(f'服务端接收到了信息 {info}'.encode())

    dataSocket.close()

# 实例化一个socket对象 用来监听客户端连接请求
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))

listenSocket.listen(8)
print(f'服务端启动成功,在{PORT}端口等待客户端连接...')

while True:
   # 在循环中,一直接受新的连接请求
   dataSocket, addr = listenSocket.accept()     # Establish connection with client.
   addr = str(addr)
   print(f'一个客户端 {addr} 连接成功' )

   # 创建新线程处理和这个客户端的消息收发
   th = Thread(target=clientHandler,args=(dataSocket,addr))
   th.start()

listenSocket.close()


多线程方式有个缺点。

如果一个服务端要同时处理大量的客户端连接,比如10000个,需要创建10000个线程。

而操作系统通常不可能为一个进程分配这么多的线程。

实际上,我们的服务端程序,大部分时间都是空闲的,都在等待连接请求,等待接受消息,根本不需要这么多的线程来处理。

这种程序通常被称之为 IO bound 程序,也就是说程序的主要时间都是花费在 IO 上面。

这种程序,其实一个线程就足够了。

关键问题是,需要这一个线程 很好的分配 时间, 在有连接请求到来的时候,执行处理连接请求代码,有消息到达socket缓冲的时候,执行读取处理消息的代码。

这种处理方式称之为异步IO。

Python 3 新增了 asyncio 库, 我们可以使用该库来 实现 同时处理多个客户端数据收发。

示例代码如下:

#  === TCP 服务端程序 server.py 异步支持多客户端 ===
import asyncio, socket
IP = ''
PORT = 50000
BUFLEN = 512

# 定义处理数据收发的回调
async def handle_echo(reader, writer):
    while True:
        data = await reader.read(100)
        if not data:
            print(f'客户端{addr}关闭了连接')
            writer.close()
            break
        message = data.decode()
        addr = writer.get_extra_info('peername')
        print(f'收到{addr}信息: {message}')

        writer.write(data)

loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_echo, IP, PORT, loop=loop)
server = loop.run_until_complete(coro)

# Serve requests until Ctrl+C is pressed
print('服务端启动成功,在{}端口等待客户端连接...'.format(server.sockets[0].getsockname()))
try:
    loop.run_forever()
except KeyboardInterrupt:
    pass

# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()


微信扫码分享本文




上一页 下一页