复习：消息队列

为了防止消息丢失，或者是调用方，不需一直等待响应方的结果。

# threadtest.py

import codecsfrom queue import Queuefrom threading import Threadimport timeclass 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 Queuefrom onlive.secondlesson.threadtest import Produce, Consumerdef 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_INET6 ipv6

socket.AF_UNIX 只用于单一unix系统间进行通信

socket type:

socket.SOCK_STREAM 流式socket TCP

socket.SOCK_DGRAM 数据报式socket UDP

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 socketimport timeclass 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()