socket协议

如果进程是一幢幢房子,socket就是房子的门,而端口可以确定是哪一扇门。

通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。

socket 的典型应用就是 Web 服务器和浏览器：浏览器获取用户输入的URL，向服务器发起请求，服务器分析接收到的URL，将对应的网页内容返回给浏览器，浏览器再经过解析和渲染，就将文字、图片、视频等元素呈现给用户。

我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

socket的阻塞与非阻塞：

阻塞式的socket的recv服从这样的规则：当缓冲区内有数据时，立即返回所有的数据；当缓冲区内无数据时，阻塞直到缓冲区中有数据。

非阻塞式的socket的recv服从的规则是：当缓冲区内有数据时，立即返回所有的数据；当缓冲区内无数据时，产生EAGAIN的错误并返回（在Python中会抛出一个异常）。

两种情况都不会返回空字符串，返回空数据的结果是对方关闭了连接之后才会出现的。

socket的默认情况下是阻塞模式：socket.accept()方法在没有接受到连接之前不能处理已经建立连接的其他操作，以及在recv()方法或者其他接受数据的方法时候都是阻塞的，如果没有接受到数据就会一直处于阻塞状态，来等待接受数据，这种情况只有通过开启新的进程或者线程来解决来自不同客户端的连接请求或者接受数据；socket可以支持非阻塞的模式；可以使用以下两种方法来设置socket的非阻塞模式：

# socket.setblocking(flag)
# 设置套接字为阻塞或非阻塞模式：如果 flag 为 false，则将套接字设置为非阻塞，否则设置为阻塞。
# socket.settimeout(value)
# 如果value赋为 0，则套接字将处于非阻塞模式。如果指定为 None，则套接字将处于阻塞模式。
# 阻塞
sock.setblocking(True)
sock.settimeout(None)
# 非阻塞
sock.setblocking(False)
sock.settimeout(0)

 

在非阻塞模式下可以实现在单线程模式下实现与多个客户端连接的交互

非阻塞模式的服务端：

# demo_socket_server_2.py文件
import logging
import socket

logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s>%(message)s", datefmt="%Y-%m-%d %H:%M:%S")
logger = logging.getLogger(__name__)


class ServerClass(object):
    """docstring for ServerClass"""

    def __init__(self):
        self.__HOST = "127.0.0.1"
        self.__PORT = 9999
        self.ADDR = (self.__HOST, self.__PORT)
        self.__TCP_SOCKET = socket.socket(
            family=socket.AF_INET, type=socket.SOCK_STREAM)
        # 设置非阻塞
        # self.__TCP_SOCKET.setblocking(False)
        self.__TCP_SOCKET.settimeout(0.0)
        # 用来存放套接字对象的列表
        self.connlist = list()

    def start_server(self):
        with self.__TCP_SOCKET as sock:
            sock.bind(self.ADDR)
            sock.listen()
            logger.info("Server is Running")
            while True:
                try:
                    conn, addr = sock.accept()
                    # logger.info(conn)
                    # 将连接的套接字对象设置为非阻塞
                    conn.setblocking(False)
                    msg = f"Hi,{addr}"
                    self.send_data(conn, msg)
                    # 添加到列表
                    self.connlist.append(conn)
                # 如果没有连接进来需要捕获BlockingIOError异常
                except BlockingIOError as e:
                    pass
                    # logger.debug("没有新的客户端连接")
                # 循环套接字对象列表 进行收发数据
                for conn in self.connlist:
                    msg = self.recv_data(conn)
                    self.send_data(conn, msg)

    def recv_data(self, conn):
        """接收数据"""
        try:
            msg = conn.recv(1024).decode("utf-8")
            if not msg or msg in ["quit"]:
                logger.debug("断开连接")
                # 将套接字对象从列表移除
                self.connlist.remove(conn)
            else:
                logger.info(msg)
                return msg
        except IOError as e:
            pass
            # logger.debug("没有接收到数据")

    def send_data(self, conn, msg):
        """发送数据"""
        if msg:
            msg = f"From Server {msg}"
            try:
                conn.sendall(msg.encode("utf-8"))
            except ConnectionResetError as e:
                pass
                logger.debug("连接已断开，无法再发送信息")


if __name__ == '__main__':
    ServerClass().start_server()

服务端非阻塞模式的情况下 主要通过循环控制不停的去捕获BlockingIOError 异常来判断是否有新的连接进来，或者是是否有数据可以接受到；该情况下CPU的使用率会很高。

客户端代码：

import logging
import time
import socket
import threading

# demo_logging_1.load_loggingconfig()
logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s>%(message)s", datefmt="%Y-%m-%d %H:%M:%S")
logger = logging.getLogger(__name__)


class ClientClass(object):
    """docstring for ClientClass"""

    def __init__(self):
        self.__HOST = "127.0.0.1"
        self.__PORT = 9999
        self.__ADDR = (self.__HOST, self.__PORT)
        self.__TCP_SOCKET = socket.socket(
            family=socket.AF_INET, type=socket.SOCK_STREAM)

    def start_client(self):
        """启动客户端"""
        with self.__TCP_SOCKET as sock:
            # 链接服务端地址
            sock.connect(self.__ADDR)
            logger.info("%s" % sock.recv(1024).decode("utf-8"))
            recv_t = threading.Thread(
                target=self.recv_data, args=(sock,))
            # 向服务端发送数据
            send_t = threading.Thread(
                target=self.send_data, args=(sock,))
            # 接收数据线程设置为守护线程
            recv_t.setDaemon(True)
            recv_t.start()
            send_t.start()
            send_t.join()

    def send_data(self, sock):
        while True:
            send_data = input()
            sock.sendall(send_data.encode("utf-8"))
            # 如果输入 quit 或者 exit 断开连接
            if send_data in ("quit"):
                logger.info("正在退出...")
                break

    def recv_data(self, sock):
        while True:
            try:
                recv_data = sock.recv(1024).decode("utf-8")
                logger.info(recv_data)
            except Exception as e:
                pass
                # logger.error(e, exc_info=True)
                time.sleep(0.5)
                break


if __name__ == '__main__':
    ClientClass().start_client()

效果（服务端不需要多开启进程或者线程就可以实现与多个客户端之间通信）：

 

其他案例：

python实现socket协议通信

 

 

 

保持独立思考，就是不要轻易的受到外在的影响,因为每天带给你们痛苦的更多的言论是外界的声音，所以你可以保持自己独立的选择和独立的判断，学会做一个独立思考的人。