python网络编程与并发编程#2

一.Socket抽象层(socket编程)

1. socket编程

        

        Socket抽象层是计算机网络中的一个概念，它是一种对网络通信进行编程的接口。Socket抽象层提供了一组API（Application Programming Interface，应用程序编程接口）以实现网络通信，这些API包括建立网络连接、发送和接收数据、关闭网络连接等操作。

在Socket抽象层中，网络通信被看作一种面向流的方式，即数据通过网络以字节流的形式传输。Socket抽象层支持两种传输协议：TCP（Transmission Control Protocol，传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）。TCP协议提供可靠的数据传输和错误检测，而UDP协议则提供了快速的数据传输和更少的开销。

Socket抽象层不仅可以用于构建网络服务器和客户端程序，也可以用于实现各种应用程序，例如网络游戏、聊天软件等。它是计算机网络中非常重要的一个概念。我们一般把socket翻译成套接字

基于文件类型的套接字名字家族：AF_UNIX

基于网络类型的套接字名字家族：AF_INET

2. socket模块的基本使用

socket模块的基本使用
1.socket.socket()    产生socket对象
2.bind()             绑定地址
3.listen()           半连接池
4.accept()           等待客户端链接
5.send()             发送消息
6.recv()             接收消息
7.connect()          链接服务端

流程图：

3. 基于TCP协议的套接字(socket)编程

服务端代码：

import socket
from socket import AF_INET
server = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
"""# family=AF_INET，type=SOC_STRAM是基于TCP协议的
    server = socket.socket(family=AF_INET, type=socket.SOCK_DGRAM)
      是基于UDP协议的"""

绑定ip地址与port：

import socket
from socket import AF_INET
server = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8000))

服务端做监听（半连接池）

服务端可以同时等待客户端的数量：

import socket
from socket import AF_INET  # 使用TCP协议
"""服务端使用的什么协议，客户端基使用什么协议"""

client = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8001)) # 绑定的ip地址与port

接受客户端发送的信息

import socket
from socket import AF_INET  # 使用TCP协议
"""服务端使用的什么协议，客户端基使用什么协议"""

client = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8001)) # 绑定的ip地址与port
client.send('hello'.encode('utf-8'))    # 向服务端输出的信息并且转为二进制
date = client.recv(1024)

print('服务端发送的信息', date)

客户端完整代码：

import socket
from socket import AF_INET  # 使用TCP协议
"""服务端使用的什么协议，客户端基使用什么协议"""

client = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8001)) # 绑定的ip地址与port
client.send('hello'.encode('utf-8'))    # 向服务端输出的信息并且转为二进制
date = client.recv(1024)

print('服务端发送的信息', date)
client.close()  # 关闭

服务端完整代码：

import socket
from socket import AF_INET
server = socket.socket(family=AF_INET, type=socket.SOCK_STREAM) #使用TCP协议
server.bind(('127.0.0.1', 2000)) # 绑定ip与port
server.listen(3) #监听

sock, addr = server.accept()
data = sock.recv(1024)
print('接受客户端信息', data)

sock.send(data.upper())# 返回客户端的内容大写
sock.close()
server.close()

通信与通信循环

服务端：

import socket
from socket import AF_INET
server = socket.socket(family=AF_INET, type=socket.SOCK_STREAM) #使用TCP协议
server.bind(('127.0.0.1', 2000)) # 绑定ip与port
server.listen(3) #监听
while True:
    sock, addr = server.accept()
    while True:
        try:
            data = sock.recv(1024)
            print('接受客户端信息', data)

            sock.send(data.upper())# 返回客户端的内容大写
        except Exception as e:
            print(e)
            break
        sock.close()
        server.close()

客户端：

import socket
from socket import AF_INET  # 使用TCP协议
"""服务端使用的什么协议，客户端基使用什么协议"""
client = socket.socket(family=AF_INET, type=socket.SOCK_STREAM)# 使用服务端相同的协议
client.connect(('127.0.0.1', 2000)) # 绑定相同的ip与port
while True:
    send = input('请输入传入的内容')
    # 开始传输信息
    client.send('lll'.encode('utf-8'))
    # 接受服务端发送的信息
    data = client.recv(1024)
    print('接受客户端发送的信息', data)
    client.close()

4. 基于UDP协议的套接字编程

服务端

import socket
from socket import AF_INET
server = socket.socket(family=AF_INET, type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 2000))
while True:
    data, client_addr = server.recvfrom(1024)
    print('输出结果', data,  client_addr)
    server.sendto(data.upper(), client_addr)
server.close()

客户端
 

import socket
client = socket.socket(socket.AF_INET, type=socket.SOCK_DGRAM)

while True:
    msg = input('输入输出的结果').strip()
    client.sendto(msg.encode('utf-8'), ('127.0.0.1', 2000))
    data, server_addr = client.recvfrom(1024)
    print(data)

client.close()

二. 粘包现象

粘包现象：执行两端的操作，服务端一次性接收到客户端三次的消息:发送端需要等缓冲区满才发送出去，造成黏包（发送数据时间间隔很短，数据很小，会合并一起，产出黏包。

同时将接收的字节数改为5个字节，服务端接收客户端的字节不够，就会朝着第二次客户端发送的字节拿一个字节，第二次打印就会从上次断开的地方接着打印（接收方不及时接收缓冲区的包，造成多个包接收）

要是想解除上述现象，服务端接收的字节数就必须根据客户端发送的数据大小

1. 粘包现象产生的原因

1. 不清楚客户端所发送的数据大小

2. TCP协议也被称流式协议，数据想流水一样，不间断，当所传数据小于服务端的最大传输时，将会直接一次性合并传输过去。

粘包现象只存在于TCP协议中，表面上是因为TCP协议中的发送方和接受方缓存机制，实际上是不清楚发送方所发送数据的大小所导致的，所以我们需要在发送数据前，先使用send发送该字节流的长度，这种方式会放大网络延迟带来的性能损耗

2. 如何避免粘包现象

如何确定服务端每次接收到的字节数，如何将长度变化的数据全部制作成固定长度的数据？

引入：struct模块

3. struct模块

我们可以借助一个模块struct，他可以把我们需要发送的数据长度转化为固定长度的字节，这客户端每次接受消息之前先接受这个固定长度字节的内容，去确认有接受数据字节的大小，最终接受的数据达到一个值就停止，刚好可以刚好接受完整的数据了

示例：

关键字：struct.pack转为固定的长度

struct.unpack 求出实际的长度

import struct
info = b'hello,jerry'
"""数据的真实长度"""

print(len(info))    # 11
"""将数据打包成固定的长度"""

res = struct.pack('i', len(info))
"""打包之后的长度为"""
print(len(res))    # 4

"""根据固定的长度取出实际的长度"""
res1 = struct.unpack('i', res)
print(res1)    # (11,)