46. Python Socket编程

q29191

　　复习：消息队列
　　为了防止消息丢失，或者是调用方，不需一直等待响应方的结果。
　　# threadtest.py
import codecs　　
from queue import Queue
　　
from threading import Thread
　　

　　
import time
　　

　　

　　
class Produce(Thread):
　　
    def __init__(self, queue):
　　
        super(Produce, self).__init__()
　　
        self.fileName = "../firstlession/passwd"
　　
        self.fileList = list()
　　
        self.queue = queue
　　
    def run(self):
　　
        with codecs.open(self.fileName) as f:
　　
            self.fileList += f.readlines()
　　
        for line in self.fileList:
　　
            self.queue.put(line)
　　

　　
class Consumer(Thread):
　　
    def __init__(self, queue):
　　
        self.queue = queue
　　
        super(Consumer, self).__init__()
　　
        self.newPasswd = "newpasswd.txt"
　　
        self.fileList = list()
　　
        self.stat = 1
　　
    def run(self):
　　
        while 1:
　　
            if self.queue.empty():
　　
                time.sleep(2)
　　
                self.stat += 1
　　
                if self.stat == 5:
　　
                    break
　　
            else:
　　
                self.stat = 1
　　
                data = self.queue.get()
　　
                self.fileList.append(data)
　　

　　
        with codecs.open(self.newPasswd, 'w') as f:
　　
            f.writelines(self.fileList)
　　
　　调用
　　# thread1.py
from queue import Queue　　
from onlive.secondlesson.threadtest import Produce, Consumer
　　

　　
def main():
　　
    q = Queue()
　　
    produce = Produce(q)
　　
    consumer = Consumer(q)
　　
    produce.start()
　　
    consumer.start()
　　

　　
if __name__ == '__main__':
　　
    main()
　　socket 简介
　　TCP的可靠性实现：
　　（1）校验码
　　（2）接收方反馈
　　（3）信息包附带序号
　　UDP：
　　（1）快不需要花费时间建立和关闭连接
　　（2）快偶尔丢失一两个消息包无所谓，但是TCP会严格检查
　　（3）快UDP的限制是一个信息包不超过64KB的数据
　　TCP和UDP区别：
　　UDP不建立连接，只保证数据的完整性，数据传输快，但是不保证数据是否真的被收到，也不保证数据是否只接收一次，也不保证次序。
　　TCP则相反。
　　服务端是用来给一个或多个客户端提供服务的，当客户端发起请求，开始等待服务端的返回结果，服务端接受完请求以后，根据自己的逻辑处理请求，并返回给客户端，客户端接收到返回结果以后，关闭和服务端的连接。
　　[备注]：只要是发送数据的就是"写"，只要是接收数据的就是"读"。
　　最常用的客户端和服务端有两种模式：C/S模式（mysql） 和   B/S模式（百度、京东、淘宝网站等）
　　socket流程：
　　（1）服务端创建完一个socket以后
　　（2）需要绑定一个IP:PORT
　　（3）对其进行监听（listen）-->【监听的方法内需要带一个数字，这个数字表示同时有多少个客户端可以来访问服务端】
　　（4）然后接收请求（accept）--> 【客户端每创建一个连接，调用 "connect函数" 后，服务端就需要生成一个新的socket连接和客户端进行传输，传输完成后关闭客户端连接、关闭服务端；服务端永远要比客户端多一个socket连接，如果说客户端是n个socket连接，那么服务端就要创建n+1个socket连接，因为刚开始启动服务端的时候，服务端就要创建一个socket连接，每当从客户端过来一个连接，服务端就要创建一个socket连接跟客户端进行交互，所以服务端比客户端多一个连接。】

　　socket常用函数讲解：
　　创建套接字：
　　s = socket.socket(address family, socket type)
　　address family:
　　socket.AF_INET默认ipv4
　　socket.AF_INET6ipv6
　　socket.AF_UNIX只用于单一unix系统间进行通信
　　socket type:
　　socket.SOCK_STREAM流式socketTCP
　　socket.SOCK_DGRAM数据报式socketUDP
　　TCP 方式 socket：
　　（1）创建socket：
　　s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
　　（2）绑定地址：
　　address = ('0.0.0.0', 8009)
　　s.bind(address) 或者 s.bind((0.0.0.0, 8009)) 两种方式相同；
　　【注意：address 必须是一个元组，容易错误，address = (host, port)】
　　【host：服务端ip，字符串类型，如果为0.0.0.0，代表本机的任意一个IP】
　　【port：服务端提供的端口，整形，0-1024为系统保留（不选这里面的端口）】
　　（3）监听消息：
　　s.listen(badklog)
　　backlog 代表可以同时接受多少个socket连接
　　（4）接受连接：
　　conn, addr = s.accept()
　　接受连接并返回元组(conn,addr)，其中conn是新的套接字对象，每个新的连接就创建一个新的对象。可以用来接受和发送数据，addr是客户端的地址：包含host和port。
　　（5）发送数据：
　　s.send(string)发送字符串到连接的套接字，可能未将指定内容全部发送；
　　s.sendall(string)内部递归调用send，将所有内容发送出去，建议使用。
　　（6）接收数据：
　　data = s.recv(bufsize)
　　接收套接字数据，数据以字符串形式返回，bufsize指定最多接收的数据量，可以使用1024， 2048
　　如果不知道接收的数量有多少，可以能几个字节，可能几兆，一般通过循环接收。
　　UDP 方式 socket：
　　s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
　　s.sendto(string)
　　data, address = s.recvfrom(bufsize)
　　客户端：
　　客户端首先也要创建socket套接字
　　s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
　　客户端连接服务端函数：
　　s.connect(address)#连接到address的套接字
　　result - connect_ex(address)#成功返回0，失败返回错误码
　　通用：
　　s.close()#关闭套接字
　　s.getsocketname()  #获取套接字的名字
　　s.settimeout(timeout)#设置套接字超时时间，timeout为float类型，单位秒
　　s.gettimeout()#获得套接字超时时间
　　s.setblocking(flag)#flage为bool值
　　setblocking(True) is equivalent to settimeout(None); #不设置超时时间，一直阻塞在那里
　　setblocking(False) is equivalent to settimeout(0.0);#设置超时时间为0，如果设置False，accept和recv一旦无数据，则报错。
　　s.fileno()# 返回套接字的文件描述符（一个小整数）。这对于select.select()是有用的。
　　socket例子：
　　写socket工具：
　　# util.py
import socket　　
import time
　　

　　

　　
class InitSocketTest(object):
　　
    def __init__(self, host, port, type):
　　
        self.host = host
　　
        self.port = port
　　
        self.address = (host, port)
　　
        self.type = type
　　
        self.s = None
　　
        self.creatsocket()
　　

　　
    def creatsocket(self):
　　
        if self.type.upper() == "TCP":
　　
            self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
　　
        elif self.type.upper == "UDP":
　　
            self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
　　
        else:
　　
            print("you must input the InitSocket(type) is 'UDP|TCP' ")
　　

　　
class SocketServerTest(InitSocketTest):
　　
    def __init__(self, host, port, type,  backlog):
　　
        self.backlog = backlog
　　
        super(SocketServerTest, self).__init__(host, port, type)
　　
        self.clientAddress = None
　　

　　
    def run(self):
　　
        self.s.bind(self.address)
　　
        self.s.listen(self.backlog)
　　
        print("server starting…………")
　　
        conn, self.clientAddress = self.s.accept()
　　
        print("accept connect from {0}".format(self.clientAddress))
　　
        for i in range(1, 10):
　　
            conn.sendall("i = {0}".format(str(i)).encode("utf-8"))
　　
        self.s.close()
　　

　　
class ClientSocketTest(InitSocketTest):
　　
    def run(self):
　　
        self.s.connect(self.address)
　　
        stat = 1
　　
        while 1:
　　
            data = self.s.recv(2048)
　　
            if len(data)>0:
　　
                stat = 1
　　
                print(data.decode("utf-8"))
　　
            else:
　　
                stat += 1
　　
                time.sleep(1)
　　
                if stat == 5:
　　
                    break
　　# testserver.py
from onlive.sockettest.util import SocketServerTest　　
if __name__ == '__main__':
　　
    socketServer = SocketServerTest(host="0.0.0.0", port=9999, type="tcp", backlog=5)
　　
    socketServer.run()
　　# testclient.py
from onlive.sockettest.util import ClientSocketTest　　
if __name__ == '__main__':
　　
    socketClient = ClientSocketTest(host="127.0.0.1", port=9999, type="tcp")
　　
    socketClient.run()