复习：消息队列
为了防止消息丢失，或者是调用方，不需一直等待响应方的结果。
# 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_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 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()
