Python基础学习（5）网络编程socket套接字、文件上传、粘包问题、socketserver、IO多路复用、线程进程协程、进程池、线程池、上下文管理
1. socket套接字
socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。
1）套接字分类
（1）基于文件类型的套接字家族：AF_UNIX
（2）基于网络类型的套接字家族：AF_INET
简单的Server与Client案例：
import socket
# Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 9999, ))
server.listen(5)
# 接收客户端的请求
# 连接客户端地址信息
while True:
conn, addr = server.accept()
print(conn, addr)import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))
client.close()实现简单交互的socket案例 版本一：
import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)
# 接收客户端的请求
# 连接客户端地址信息
while True:
conn, addr = server.accept()
conn.sendall(bytes("Hello World", encoding = "utf-8"))
while True:
rec_bytess = conn.recv(1024)
rec_str = str(rec_bytess, encoding="utf-8")
if rec_str == "exit":
break
conn.sendall(bytes(rec_str + "!", encoding="utf-8"))
print(conn, addr)
import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))
rec = client.recv(1024)
rec_str = str(rec, encoding="utf-8")
print(rec_str)
while True:
inp = input("请输入要发送的内容：")
if inp == "exit":
client.sendall(bytes(inp, encoding="utf-8"))
break
else:
client.sendall(bytes(inp, encoding="utf-8"))
ret = str(client.recv(1024), encoding="utf-8")
print(ret)
client.close()版本二，可以对多个客户端提供服务，但没有实现多线程：
import socket
socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
socket.bind(('127.0.0.1', 8001))
socket.listen(5)
print('starting...')
while True: # 链接循环
conn, client_addr = socket.accept()
print(client_addr)
while True: # 通信循环
try:
data = conn.recv(1024)
if not data: break # 适用于linux系统
print('客户端数据： ', data)
conn.send(data.upper())
except ConnectionResetError: # 适用于windows系统
break
conn.close()
socket.close()import socket
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connet(('127.0.0.1', 8001))
while True:
msg = input('>>: ').strip()
if not msg: continue:
socket.send(msg.encode('utf-8'))
data = socket.recv(1024)
print(data.decode('uff-8))
socket.close()模拟ssh远程执行命令
Server:
import socket
import subprocess
socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1',8002))
socket.listen(5)
while True:
conn,client = socket.accept()
while True:
try:
cmd = conn.recv(1024)
if not cmd: break
obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read()
conn.send(stdout + stderr)
except ConnectionResetError:
break
conn.close()
socket.close()Client:
import socket
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1', 8002))
while True:
cmd = input('>>: ').strip()
if not cmd: continue
socket.send(cmd.encode('utf-8'))
data = socket.recv(1024)
print(data.decode('uff-8')
socket.close()1）sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
参数一：地址簇
socket.AF_INET IPV4（默认）
socket.AF_INET6 IPV6
socket.AF_UNIX 只能够用于单一的Unix系统进程间tongxin
参数二：类型
socket.SOCK_STREAM 流式socket, for TCP（默认）
socket.SOCK_DGRAM 数据报式socket，for UDP
socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，二SOCK_RAW可以，其次，SOCK_RAW也可以处理特殊的IPv4报文，此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_RDM是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
socket.SOCK_SEQPACKET 可靠的连续数据包服务
参数三：协议
0 （默认）与特定的地址家族相关的协议，如果是0，则系统就会根据地址格式和套接类别，自动选择一个合适的协议
2）sk.bind(address)
sk.bind(address)将套接字绑定到地址。address地址的格式取决于地址簇。在AF_INET下，以元组(host,port)的形式表示地址。
3）sk.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列
4）sk.setblocking(bool)
是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
5）sk.accept()
接受连接并返回（conn, address），其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
接收TCP客户的连接（阻塞式）等待连接的到来
6）sk.connect(address)
连接到address处的套接字。一般address的格式为元组(hostname, port)，如果连接出错，返回socket.error错误。
7）sk.connect_ex(address)
同上，只不过会返回值，连接成功时返回0，连接失败时返回编码，例如：10061
8）sk.close()
关闭套接字
9）sk.recv(bufsize[,flag])
接收套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
10）sk.recvfrom(bufsize[.flag])
与recv()类似，但返回值是(data, address)。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
11）sk.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
12）sk.sendall(string[,flag])
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常
内部通过递归调用send，将所有内容发送出去。
13）sk.sendto(string[,flag],address)
将数据发送到套接字，address是形式为(ipaddr, port)的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
14）sk.settimeout(timeout)
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如client连接最多等待5s）
15）sk.getpeername()
返回连接套接字的远程地址。返回值通常是元组(ipaddr, port)
16）sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr, port)
17）sk.fileno()
套接字的文件描述符
18）socket.setsocketopt(socket.SOL_SOCKET, socket.REUSEADDR, 1)
重用ip和端口
3. 使用socket实现文件上传
import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)
# 接收客户端的请求
# 连接客户端地址信息
while True:
conn, addr = server.accept()
# 先接收文件大小
file_size = str(conn.recv(1024), encoding="utf-8")
total_size = int(file_size)
has_recv = 0
f = open("logo.png", "wb")
# 然后再开始接收，直到获取完毕
while True:
if has_recv == total_size:
break
data = conn.recv(1024)
f.write(data)
has_recv += len(data)
f.close()import socket
import os
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))
# 发送当前文件大小
file_size = os.stat("fudan.png").st_size
client.sendall(bytes(str(file_size), encoding="utf-8"))
with open("fudan.png", "rb") as f:
for line in f:
client.sendall(line)
client.close()4. 粘包问题
import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)
# 接收客户端的请求
# 连接客户端地址信息
while True:
conn, addr = server.accept()
# 先接收文件大小
file_size = str(conn.recv(1024), encoding="utf-8")
# 接收到文件大小之后，再向客户端发送一个确认信息，以解决粘包问题
conn.sendall(bytes("Start to transfer the file", encoding="utf-8"))
total_size = int(file_size)
has_recv = 0
f = open("logo.png", "wb")
# 然后再开始接收，直到获取完毕
while True:
if has_recv == total_size:
break
data = conn.recv(1024)
f.write(data)
has_recv += len(data)
f.close()
import socket
import os
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))
# 发送当前文件大小
file_size = os.stat("1.png").st_size
client.sendall(bytes(str(file_size), encoding="utf-8"))
# 发送文件大小之后，等待服务器端的确认信息，以解决粘包问题
client.recv()
with open("1.png", "rb") as f:
for line in f:
client.sendall(line)
client.close()制作报头，解决粘包问题
import socket
import subprocess
import struct
import json
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1', 8002))
socket.listen(5)
while True:
conn, client_addr = socket.accept()
print(client_addr)
while True:
try:
# 1. 接受命令
cmd = conn.recv(1024)
print(cmd)
if not cmd:
break
# 2. 执行命令，获取结果
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read()
# 3. 把命令的结果返回给客户端
# 第一步：制作固定长度的报头
header_dict = {
'filename': '1.txt',
'md5': 'abc',
'total_size': len(stdout) + len(stderr)
}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode('utf-8')
# 第二步：先发送报头的长度
conn.send(struct.pack('i', len(header_bytes)))
# 第三步：再发报头
conn.send(header_bytes)
# 第四步：再发送真实的数据
conn.send(stdout)
conn.send(stderr)
except ConnectionResetError:
break
conn.close()
socket.close()import socket
import struct
import json
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(('127.0.0.1', 8002))
while True:
# 1. 发命令
cmd = input('>>: ').strip()
if not cmd:
continue
# 2. 拿命令的结果并打印
# 第一步：先收报头长度
obj = socket.recv(4)
header_size = struct.unpack('i', obj)[0]
print(header_size)
# 第二步：再收报头
header_bytes = socket.recv(header_size)
# 第三步：从报头中解析出对真实数据的描述信息
header_dic = json.loads(header_bytes.decode('utf-8'))
total_size = header_dic['total_size']
print(total_size)
# 第四步：接受真实的数据
recv_size = 0
recv_data = b''
while recv_size < total_size:
res = socket.recv(1024)
recv_data += res
recv_size += len(res)
print(recv_data.decode('utf-8'))
socket.close()5. socketserver，并发处理多个客户端请求
使用方法：
- 创建类，必须继承socketserver.BaseRequestHandler
- 实现handle方法
- 使用server_forever启动循环
socketserver服务器端实现的简单案例：
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
# self.request客户端的连接；
# self.client_address客户端地址；
# self.server当前服务器socket对象
conn = self.request
conn.sendall(bytes("Hello World", encoding="utf-8"))
while True:
ret_bytes = conn.recv(1024)
ret_str = str(ret_bytes, encoding="utf-8")
if ret_str == "q":
break
conn.sendall(bytes(ret_str + "!", encoding="utf-8"))
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(("127.0.0.1", 8008), MyServer)
server.serve_forever()IO多路复用：通过一种机制，可以监视多个文件描述符（文件句柄），一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。与python没有关系，是系统底层实现的
简单案例：
import socket
# Server
sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.bind(("127.0.0.1", 8001))
sk1.listen(5)
sk2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk2.bind(("127.0.0.1", 8002))
sk2.listen(5)
sk3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk3.bind(("127.0.0.1", 8003))
sk3.listen(5)
inputs = [sk1, sk2, sk3]
import select
while True:
# [sk1, sk2, sk3]内部自动监听sk1, sk2连个对象，
# 一旦某个文件描述符发生变化，则进行操作
# 如果有人连接sk1，r_list = [sk1]
# 第一个参数（r_list）为一有变化便能监听到，第三个参数（e_list）为一发生错误能监听到
# 只要有值w_list就能获取值，第二个参数传了什么会原封不动地传给w_list
# e_list中的数据表示该socket出错
# 最后一个参数为最多等待的时间，1秒
r_list, w_list, e_list = select.select(inputs, [], [], 1)
for sk in r_list:
# 每个连接对象
conn, address = sk.accept()
# 连接之后就发送一条信息
conn.sendall(bytes("Hello World!", encoding="utf-8"))
# 如果有连接出错了，就将其从列表中移除
for sk in e_list:
inputs.remove(sk)
import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 8001))
ret = str(client.recv(1024), encoding="utf-8")
print(ret)
while True:
inp = input(">>> ")
if inp == "q":
client.send(bytes(inp, encoding="utf-8"))
break
else:
client.send(bytes(inp, encoding="utf-8"))
ret = str(client.recv(1024), encoding="utf-8")
print(ret)
client.close()import socket
# Server
sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.bind(("127.0.0.1", 8001))
sk1.listen(5)
# sk2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sk2.bind(("127.0.0.1", 8002))
# sk2.listen(5)
#
# sk3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sk3.bind(("127.0.0.1", 8003))
# sk3.listen(5)
inputs = [sk1,]
import select
while True:
# select内部自动监听socket对象，一旦socket变换感知到
#
r_list, w_list, e_list = select.select(inputs, [], [], 1)
print("正在监听的socket对象%d" % len(inputs))
print(r_list)
for sk_or_conn in r_list:
# 每个连接对象
if sk_or_conn == sk1:
# 表示有新用户来连接
conn, address = sk_or_conn.accept()
inputs.append(conn)
else:
# 有老用户发消息了
try:
data_bytes = sk_or_conn.recv(1024)
data_str = str(data_bytes, encoding="utf-8") + "!"
sk_or_conn.sendall(bytes(data_str, encoding="utf-8"))
except Exception as ex:
# 如果发送错误，则从列表中移除
inputs.remove(sk_or_conn)
# 连接之后就发送一条信息
conn.sendall(bytes("Hello World!", encoding="utf-8"))
# 如果有连接出错了，就将其从列表中移除
for sk in e_list:
inputs.remove(sk)
import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 8001))
ret = str(client.recv(1024), encoding="utf-8")
print(ret)
while True:
inp = input(">>> ")
if inp == "q":
client.send(bytes(inp, encoding="utf-8"))
break
else:
client.send(bytes(inp, encoding="utf-8"))
ret = str(client.recv(1024), encoding="utf-8")
print(ret)
client.close()import socket
# Server
sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.bind(("127.0.0.1", 8001))
sk1.listen(5)
# sk2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sk2.bind(("127.0.0.1", 8002))
# sk2.listen(5)
#
# sk3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sk3.bind(("127.0.0.1", 8003))
# sk3.listen(5)
inputs = [sk1,]
outputs = []
message_dict = {}
import select
while True:
# select内部自动监听socket对象，一旦socket变换即感知到
r_list, w_list, e_list = select.select(inputs, outputs, inputs, 1)
print("正在监听的socket对象%d" % len(inputs))
print(r_list)
# 监听并读取数据
for sk_or_conn in r_list:
# 每个连接对象
if sk_or_conn == sk1:
# 表示有新用户来连接
conn, address = sk_or_conn.accept()
inputs.append(conn)
message_dict[conn] = []
else:
# 有老用户发消息了
try:
data_bytes = sk_or_conn.recv(1024)
except Exception as ex:
# 如果发送错误，则从列表中移除
inputs.remove(sk_or_conn)
else:
# 用户正常发送消息
data_str = str(data_bytes, encoding="utf-8") + "!"
message_dict[sk_or_conn].append(data_str)
outputs.append(sk_or_conn)
# w_list仅仅保存了谁给我发过消息
# w_list=[]
for conn in w_list:
recv_str = message_dict[conn][0]
if recv_str:
conn.sendall(bytes(recv_str + "!", encoding="utf-8"))
del message_dict[conn][0]
outputs.remove(conn)
7. 线程与进程
多线程的简单案例：
import threading
import time
def process(arg):
time.sleep(1)
print(arg)
for i in range(10):
t= threading.Thread(target = process, args = (i,))
t.start()1）进程
（1）进程：进程指的是程序的运行过程。不是越多越好，最理想状态为：进程数=CPU个数
进程的3个状态：进行、阻塞、就绪
- 优点：同时利用多个CPU，能够同时进行多个操作
- 缺点：耗费资源（重新开辟多个内存空间）
可以通过设置daemon让进程等待子线程执行：p.daemon = True
主线程等待子线程执行：join(2) # 有参数的话为最多等待时间时间，此处为最多等待2秒
（2）调用进程的两种方式：
# 方式一
from multiprocessing import Process
import time
def task(name):
print("%s is running..." % name)
time.sleep(3)
print("%s is done" % name)
if __name__ == "__main__":
p1 = Process(target=task, kwargs={'name': '子进程1'})
p2 = Process(target=task, args=('子进程2',))
p1.start()
p2.start()
print("主进程")# 方式二
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print("%s is running..." % self.name)
time.sleep(3)
print("%s is done" % self.name)
if __name__ == "__main__":
p1 = MyProcess('子进程1')
p2 = MyProcess('子进程2')
p1.start()
p2.start()
print("主线程")（3）查看当前进程的id以及查看父进程的id
查看当前进程的id：os.getpid()
查看父进程的id：os.getppid()
from multiprocessing import Process
import time, os
def task(name):
print("%s is running... parent id is %s" % (os.getpid(), os.getppid()))
time.sleep(3)
print("%s is done, parent id is %s" % (os.getpid(), os.getppid()))
if __name__ == "__main__":
p1 = Process(target=task, kwargs={'name': '子进程1'})
p2 = Process(target=task, args=('子进程2',))
p1.start()
p2.start()
print("主进程")（4）Process对象的其他属性或方法
a） p.join() 等待p进程对象执行结束
b） p.is_alive() 检查p进程是否存活
c） p.terminate() 结束p进程
d） p.name 查看p进程的名字
（5）基于多进程实现冰饭的套接字
# Server端
import socket
from multiprocessing import Process
def talk(request):
while True:
try:
data = request.recv(1024)
if not data: break
print(data.decode('utf-8'))
request.send(data.upper())
except ConnectionResetError as e:
print(e)
break
request.close()
def server(ip, port):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 3)
server.bind((ip, port))
server.listen(5)
while True:
request, addr = server.accept()
p = Process(target=talk, args=(request,)) p.start()# Client端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 9001))
while True:
msg = input(">> ").strip()
if not msg: continue
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print(data.decode('utf-8'))p.start() request.close() if __name__ == "__main__": server('127.0.0.1', 9001)
（6）守护进程
如果子进程的任务在主进程任务结束后就没有存在的必要了，那么该子进程应该在开启前就被设置成守护进程。主进程代码运行结束，守护进程随即终止。
注意两点：
- 守护进程会在主进程代码执行结束后就终止
- 守护进程内无法再开启子进程，否则会抛出异常
from multiprocessing import Process
import time
import random
def task(name):
print("%s is protecting" % name)
time.sleep(5)
print("%s's protection done" % name)
if __name__ == "__main__":
p = Process(target=task, args=('Amen',))
p.daemon = True # 一定要在p.start()之前设置p为守护进程，禁止p创建子进程，并且父进程代码执行结束，p即种植运行
p.start()（7）互斥锁
from multiprocessing import Process, Lock
import time
def task(name, lock):
lock.acquire()
print("%s is running" % name)
time.sleep(3)
print("%s's done" % name)
lock.release()
if __name__ == "__main__":
lock = Lock()
for i in range(5):
p = Process(target=task, args=(i, lock,))
p.start()（8）队列
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize])：创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。maxsize是队列中允许最大项数，省略则无大小限制。队列中存放的是消息而非大数据；队列占用的是内存空间
主要方法：
q.put() 用以插入数据到队列中
q.get() 从队列读取并且删除一个元素
其他方法：
q.full() 检查队列是否已满
q.empty() 检查队列是否已空
（9）生产者消费者模型，用JoinableQueue实现
from multiprocessing import Process, JoinableQueue
import time
def producer(q):
for i in range(10):
res = '饺子%s' % i
time.sleep(0.5)
print('生产者生产了%s' % res)
q.put(res)
q.join()
def consumer(q):
while True:
res = q.get()
time.sleep(1)
print('消费者吃了%s' % res)
q.task_done()
if __name__ == "__main__":
q = JoinableQueue()
p1 = Process(target=producer, args=(q,))
p2 = Process(target=producer, args=(q,))
p3 = Process(target=producer, args=(q,))
c1 = Process(target=consumer, args=(q,))
c2 = Process(target=consumer, args=(q,))
c1.daemon = True
c2.daemon = True
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
print("主线程结束")2）线程
不是越多越好，具体案例具体分析，请求上下文切换耗时
- 优点：共享内存，IO操作时候，创造并发操作
- 缺点：抢占资源
创建进程的开销远大于创建线程
（1）创建线程的两种方式
# 方式1
from threading import Thread
import time
def run(name):
print("%s is running.." % name)
time.sleep(2)
print("%s is done." % name)
if __name__ == "__main__":
t1 = Thread(target=run, args=("线程1",))
t1.start()
print("主线程")# 方式2
from threading import Thread
import time
class MyThread(Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print("%s is running.." % self.name)
time.sleep(2)
print("%s is done." % self.name)
if __name__ == "__main__":
t1 = MyThread("线程1")
t1.start()
print("主线程")
设置主线程是否等待子线程：threading.Thread(target = func, args = (*args)).setDaemon(True)
主线程等待子线程执行：join(2) # 有参数的话为最多等待时间时间，此处为最多等待2秒
进程和线程目的：提高执行效率
IO密集型：多线程
计算密集型：多进程
GIL，全局解释器锁，用于管理多线程对CPU的使用
（2）Thread对象的属性或方法
currentThread().getName()：获取当前线程的名字
currentThread().setName()：设置当前线程的名字
t.isAlive()：检查是否存活
t.join()：等待t执行结束
从threading模块导入active_count，用active_count()方法可以查看活跃线程数
从threading模块导入enumerate，用enumerate()方法可以在列表中查看当前线程
（3）线程锁threading.RLock和threading.Lock
使用线程对数据操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。RLock为递归锁，可以连续acquire多次，能解决死锁问题
案例：
import threading
import time
global_num = 0
lock = threading.RLock()
def func():
lock.acquire() # 获取锁
global global_num
global_num += 1
time.sleep(1)
print(global_num)
lock.release() # 释放锁
for i in range(10):
t = threading.Thread(target = func)
t.start()（4） threading.Event
Event是线程间通信的机制之一，一个线程发送一个event信号，其他的线程则等待这个信号，用于主线程控制其他线程的执行。Events管理一个flag，这个flag可以使用set()设置成True或使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False
- Event.wait([timeout])：阻塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）
- Event.set()：将标识位设为True
- Event.clear()：将标识位设为False
- Event.isSet()：判断标识位是否为True
import threading
def func(event):
print("start")
event.wait()
print("execute")
event = threading.Event()
for i in range(10):
t = threading.Thread(target = func, args = (event,))
t.start()
event.clear()
inp = input(">>>")
if inp.lower() == "true":
event.set()（5）GIL
全局解释器锁，本质就是一把互斥锁。
GIL与Lock是两把锁，保护的数据不一样，前者是解释器级别的，负责保护解释器级别的数据，比如垃圾回收的数据；后者保护的是用户自己开发的应用程序的数据
（6）信号量
信号量也是一把锁，可以指定信号量为5，信号量同一时间可以有5个任务拿到锁去执行
from threading import Thread, Semaphore, currentThread
import time, random
sm = Semaphore(3)
def task():
with sm:
print("%s is running..." % currentThread().getName())
time.sleep(random.randrange(1,5))
if __name__ == "__main__":
for i in range(10):
t = Thread(target=task)
t.start()（7）定时器
from threading import Thread, Timer
import random
class Code:
def __init__(self):
self.make_cache()
def make_cache(self, interval = 30):
self.cache = self.make_code()
print(self.cache)
self.timer = Timer(interval, self.make_cache)
self.timer.start()
def make_code(self, n = 4):
res = ''
for i in range(n):
s1 = str(random.randint(0,9))
s2 = chr(random.randint(65,90))
res += random.choice([s1, s2])
return res
def check(self):
while True:
code = input("Please input the checking code: ").strip()
if code.upper() == self.cache:
print("验证码输入正确")
self.timer.cancel()
break
obj = Code()
obj.check()（8）进程池线程池
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import currentThread
import os, time, random
def task():
print("name:%s pid:%s run" % (currentThread().getName(), os.getpid()))
time.sleep(random.randint(1, 5))
if __name__ == "__main__":
# pool = ProcessPoolExecutor(5)
pool = ThreadPoolExecutor(5)
for i in range(10):
pool.submit(task,)
# 将线程池的通道关闭
pool.shutdown()
print("主线程")
（9）异步调用与回调机制
异步调用：提交完任务，不等待任务执行完毕
from concurrent.futures import ThreadPoolExecutor
import time
import random
def dive(name):
print("%s is diving..." % name)
time.sleep(random.randint(3, 5))
last_second = random.randint(30, 60)
return {"name": name, "last_second": last_second}
def check(res):
res = res.result()
name = res["name"]
last_second = res["last_second"]
print("%s dived for %s seconds" % (name, last_second))
if __name__ == "__main__":
pool = ThreadPoolExecutor(10)
for i in range(20):
pool.submit(dive, ("name%s" % i,)).add_done_callback(check)（10）基于线程池实现简单聊天程序
import socket
from concurrent.futures import ThreadPoolExecutor
def communicate(conn):
while True:
try:
msg = conn.recv(1024)
if not msg: break
conn.send(msg.upper())
except ConnectionResetError:
break
conn.close()
def server(ip, port):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((ip, port))
server.listen(5)
while True:
conn, addr = server.accept()
pool.submit(communicate, conn)
server.close()
if __name__ == "__main__":
pool = ThreadPoolExecutor(3)
server("127.0.0.1", 9001)（11）queue模块
queue就是队列，它是线程安全的
q = queue.Queue(maxsize = 0) # 构造一个先进先出的队列，maxsize指定队列长度，为0时表示队列长度无限制
q.join() # 等到对列为空的时候，再执行别的操作
q.qsize() # 返回队列的大小（不可靠）
q.empty() # 当队列为空的时候，返回True，否则返回False（不可靠）
q.full() # 当队列满的时候，返回True，否则返回False（不可靠）
q.put(item, block = True, timeout = None) # 将item放入queue尾部，item必须存在。参数block默认为True，表示队列满时会等待队列给出可用位置，为False时为非阻塞，此时如果队列已满，会引发queue.Full异常，可选参数timeout表示阻塞设置的时间过后，如果队列无法给出放入item的位置，则引发queue.Full异常
q.get(block = True, timeout = None) # 移除并返回队列头部的一个值，可选参数block默认为True，表示获取值的时候如果队列为空则阻塞，为False时不阻塞，若此时队列为空，则引发queue.Empty异常，可选参数timeout表示会表示会阻塞的时间过后，如果队列为空，则引发Empty异常
q.put_nowait(item) # 等效于put(item, block = False)
q.get_nowait() # 等效于get(item, block = False)
生产者-消费者案例：
import queue
import threading
message = queue.Queue(10)
def producer(i):
print("Produce ", i)
message.put(i)
def consumer():
msg = message.get()
print(msg)
for i in range(10):
t = threading.Thread(target = producer, args = (i,))
t.start()
for i in range(10):
t = threading.Thread(target = consumer)
t.start()补充知识点1：multiprocessing模块
multiprocessing是python的多进程管理包，和threading.Thread类似，直接从侧面用subprocessess替换线程使用GIL的方式。由于这一点，multiprocessing模块可以让程序员在给定的机器上充分利用CPU。
在multiprocessing中，通过创建Process对象生成进程，然后调用它的start()方法
from multiprocessing import Process
def func(name):
print("Hello ", name)
if __name__ == "__main__":
p = Process(target = func, args = ("Steve", ))
p.start()
p.join()补充知识点2：进程间的数据共享
在使用并发设计时最好尽可能地避免共享数据，尤其是在使用多进程的时候。如若需要共享数据，multiprocessing提供了两种方式
（1）Shared memory
数据可以用Value或Array存储在一个共享内存地图里，案例如下：
from multiprocessing import Process, Value, Array
def func(n, a):
n.value = 3.1415927
for i in range(len(a)):
a[i] = -a[i]
if __name__ == "__main__":
num = Value('d', 0.0)
arr = Array('i', range(10))
p = Process(target = func, args = (num, arr))
p.start()
p.join()
print(num)
print(arr[:])
（2）Server process
由Manager()反悔的manager提供list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value 和Array类型的支持。
from multiprocessing import Process, Manager
def func(d, l):
d[1] = "1"
d["2"] = 2
d[0.25] = None
l.reverse()
if __name__ == "__main__":
with Manager() as m:
d = m.dict()
l = m.list(range(10))
p = Process(target = func, args = (d, l))
p.start()
p.join()
print(d)
print(l)补充知识点3： 进程池
Pool类描述了一个工作进程池，有几种不同的方法让任务卸载工作进程。
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。
可以用Pool类创建一个进程池，展开提交的任务给进程池。
简单使用进程池案例：
from multiprocessing import Pool
import time
def myFun(i):
time.sleep(2)
return i + 100
def end_call(arg):
print("end_call", arg)
if __name__ == "__main__":
p = Pool(5)
for i in range(10):
p.apply_async(func = myFun, args = (i,), callback= end_call)
print("end")
p.close()
p.join()class multiprocessing.pool.Pool([processes[, initializer[m intargs[, maxtasksperchild[, context]]]]])
一个进程池对象可以控制工作进程池的哪些工作可以被提交，它支持超时和回调的异步结果，有一个类似map的实现。- processes：使用的工作进程的数量，如果processes是None那么使用os.cpu_count()返回的数量。
- initializer：如果initializer是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。
- maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个新得工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchild默认是None，意味着只要Pool存在工作进程就会一直存活。
- context：用在指定工作进程启动时的上下文，一般使用multiprocessing.Pool()或者一个context对象的Pool()方法来创建一个池，两种方法都适当地设置了context
注意：Pool对象的方法只可以被创建pool的进程所调用
进程池的方法：
- apply(func[, args[, kwds]])：使用args和kwds参数调用func函数，结果返回前会一直阻塞，由于这个原因，apply_async()更适合并发执行，另外func函数仅被pool中的一个进程运行。每个任务是排队进行的，而每个进程都执行join()方法
- apply_async(func[, args[, kwds[, callback[, error_callback]]]])：apply()方法的一个变体，会返回一个结果对象。如果callback被指定，那么callback可以接受一个参数然后被调用，当结果准备好回调时会调用callback，调用失败时，则用error_callback替换callback。Callbacks应被立即完成，否则处理结果的线程会被阻塞。每个任务都并发进行，可以设置回调函数。每个进程没有执行join()方法，daemon参数默认为True。可以通过调用pool的join方法来等待所有子进程执行完毕，但在执行pool的该方法之前，必须执行pool的close()方法或terminate()方法。
- close()：组织更多的任务提交到pool，待任务完成后，工作进程会退出。
- terminate()：不管任务是否完成，立即停止工作进程。在对pool对象进程垃圾回收的时候，会立即调用terminate()。
- join()：wait工作线程的退出，在调用join()前，必须调用close()或terminate()。这样是因为被终止的进程需要被父进程调用wait（join等价于wait），否则进程会成为僵尸进程。
- map(func, iterable[, chunksize])
- map_async(func, iterable[, chunksize[, callback[, error_callback]]])
- imap(func, iterable,[, chunksize])
- imap_unordered(func, iterable[, chunksize])
- starmap(func, iterable[, chunksize])
- starmap_async(func, iterable[, chunksize[, callback[, error_back]]])
补充知识4：线程池
简单线程池的实现：
import queue
import threading
import time
class ThreadPool(object):
def __init__(self, max_num = 20):
# 创建队列并指定队列大小
self.queue = queue.Queue(max_num)
# 在队列中放入threading.Thread类名
for i in range(max_num):
self.queue.put(threading.Thread)
# 获取队列中的threading.Thread类名
def get_thread(self):
return self.queue.get()
# 往队列中添加threading.Thread类名
def add_thread(self):
self.queue.put(threading.Thread)
def func(pool, i):
time.sleep(1)
print(i)
pool.add_thread()比较完善的线程池实现：
import queue
import threading
import time
stopEvent = object()
class ThreadPool(object):
def __init__(self, max_num):
# 队列为无限大，用以存储线程要执行的任务
self.q = queue.Queue()
# 最多创建的线程数，即线程池的最大容量
self.max_num = max_num
# 若terminal为False，则不停地去queue中取任务
self.terminal = False
# 真实创建的线程列表
self.generate_list = []
# 空闲线程列表
self.free_list = []
def run(self, func, args, callback = None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，
:return:
"""
# 将需要执行的任务的方法、参数及回调函数打包成一个元组，传入任务队列
package = (func, args, callback,)
self.q.put(package)
# 若空闲线程数为0，且创建的线程总数小于规定的最大线程数，则创建一个线程
if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
self.generate_thread()
def generate_thread(self):
"""
创建一个线程，并执行call方法
:return:
"""
t = threading.Thread(target = self.call)
t.start()
def call(self):
"""
循环去获取任务函数并执行任务函数
:return:
"""
# 获取当前线程，并放入列表
current_thread = threading.currentThread
self.generate_list.append(current_thread)
# 取任务并执行
event = self.q.get()
while event != stopEvent:
# 元组 =》 任务
# 解开任务包
# 执行任务
func, args, callback = event
try:
# 返回调用方法的返回值
ret = func(args)
# 设置一个返回状态值，若正常执行结束，返回True
status = True
except Exception as e:
# 设置一个返回状态值，若执行出错，返回False
status = False
# 将所有错误的相关信息赋值给ret
ret = e
# 如果回调函数为非空，则执行回调函数
if callback is not None:
try:
callback(status, ret)
except Exception as e:
pass
# 如果terminal为False，则持续去取任务
if self.terminal: # terminal默认为False
event = stopEvent
else:
# 标记：当前空闲了，将当前线程放入空闲线程列表
self.free_list.append(current_thread)
# 执行完上一个任务，再次获取一个任务
event = self.q.get()
self.free_list.remove(current_thread)
else:
# 不是元组，不是任务
self.generate_list.remove(current_thread)
def close(self):
num = len(self.generate_list)
while num:
self.q.put(StopAsyncIteration)
num -= 1
# 终止线程（清空队列）
def terminate(self):
# 将terminal设置为True
self.terminal = True
# 在队列中放入stopEvent
while self.generate_list:
# 在队列中放入stopEvent，以清理线程
self.q.put(stopEvent)
self.q.empty()
def work(i):
time.sleep(1)
print(i)
# 执行ThreadPool的初始化方法
pool = ThreadPool(5)
for i in range(50):
# 将任务放入队列中
# 着手开始处理任务
# - 创建线程
# - 有空闲线程时，则不再创建线程
# - 没有空闲线程时，不能高于线程池的限制
# - 根据任务个数判断
# - 线程去队列中去任务
result = pool.run(func = work, args = (i,))
pool.terminate()3）协程
协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率。
优点：
- 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因为更加轻量级
- 单线程内就可以实现并发的效果，最大限度地利用cpu
缺点：
- 协程的本质是单线程下的，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
- 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
协程的特点
- 必须在只有一个单线程里实现并发
- 修改共享数据不许加锁
- 用户程序里自己保存多个控制流的上下文栈
- 一个协程遇到IO操作自动切换到其它协程
（1）greenlet模块
from greenlet import greenlet
def eat(name):
print("%s eat 1" % name)
g2.switch('alex')
print("%s eat 2" % name)
g2.switch()
def play(name):
print("%s play 1" % name)
g1.switch()
print("%s play 2" % name)
g1 = greenlet(eat)
g2 = greenlet(play)
g1.switch('alex')（2）gevent模块
import gevent
# 利用monkey的模块给以下所有代码的io操作进行标记
from gevent import monkey; monkey.patch_all()
import time
def eat(name):
print("%s eat 1" % name)
time.sleep(3)
print("%s eat 2" % name)
def play(name):
print("%s play 1" % name)
time.sleep(4)
print("%s play 2" % name)
start_time = time.time()
g1 = gevent.spawn(eat, 'alex')
g2 = gevent.spawn(play, 'alex')
g1.join()
g2.join()
stop_time = time.time()
print(stop_time - start_time)# 基于gevent实现并发的套接字通信
from gevent import monkey, spawn; monkey.patch_all()
from socket import *
def commnunicate(conn):
while True:
try:
data = conn.recv(1024)
if not data: break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
def server(ip, port):
server = socket(AF_INET, SOCK_STREAM)
server.bind((ip, port))
server.listen(5)
while True:
conn, addr = server.accept()
spawn(commnunicate, conn)
server.close()
if __name__ == "__main__":
g = spawn(server, '127.0.0.1', 8090)
g.join()上下文管理器在线程池中的实现：
import queue
import threading
import contextlib
import time
stopEvent = object()
class ThreadPool(object):
def __init__(self, max_num):
# 队列为无限大，用以存储线程要执行的任务
self.q = queue.Queue()
# 最多创建的线程数，即线程池的最大容量
self.max_num = max_num
# 若terminal为False，则不停地去queue中取任务
self.terminal = False
# 真实创建的线程列表
self.generate_list = []
# 空闲线程列表
self.free_list = []
def run(self, func, args, callback = None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，
:return:
"""
# 将需要执行的任务的方法、参数及回调函数打包成一个元组，传入任务队列
package = (func, args, callback,)
self.q.put(package)
# 若空闲线程数为0，且创建的线程总数小于规定的最大线程数，则创建一个线程
if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
self.generate_thread()
def generate_thread(self):
"""
创建一个线程，并执行call方法
:return:
"""
t = threading.Thread(target = self.call)
t.start()
def call(self):
"""
循环去获取任务函数并执行任务函数
:return:
"""
# 获取当前线程，并放入列表
current_thread = threading.currentThread
self.generate_list.append(current_thread)
# 取任务并执行
event = self.q.get()
while event != stopEvent:
# 元组 =》 任务
# 解开任务包
# 执行任务
func, args, callback = event
try:
# 返回调用方法的返回值
ret = func(args)
# 设置一个返回状态值，若正常执行结束，返回True
status = True
except Exception as e:
# 设置一个返回状态值，若执行出错，返回False
status = False
# 将所有错误的相关信息赋值给ret
ret = e
# 如果回调函数为非空，则执行回调函数
if callback is not None:
try:
callback(status, ret)
except Exception as e:
pass
# 如果terminal为False，则持续去取任务
if self.terminal: # terminal默认为False
event = stopEvent
else:
with worker_state(self.free_list, current_thread):
event = self.q.get()
# # 标记：当前空闲了，将当前线程放入空闲线程列表
# self.free_list.append(current_thread)
# # 执行完上一个任务，再次获取一个任务
# event = self.q.get()
# self.free_list.remove(current_thread)
else:
# 不是元组，不是任务
self.generate_list.remove(current_thread)
def close(self):
num = len(self.generate_list)
while num:
self.q.put(StopAsyncIteration)
num -= 1
# 终止线程（清空队列）
def terminate(self):
# 将terminal设置为True
self.terminal = True
# 在队列中放入stopEvent
while self.generate_list:
# 在队列中放入stopEvent，以清理线程
self.q.put(stopEvent)
self.q.empty()
def work(i):
time.sleep(1)
print(i)
# 实现上下文管理的方法
@contextlib.contextmanager
def worker_state(self, state_list, worker_thread):
state_list.append(worker_thread)
try:
yield
finally:
state_list.remove(worker_thread)
# 执行ThreadPool的初始化方法
pool = ThreadPool(5)
for i in range(50):
# 将任务放入队列中
# 着手开始处理任务
# - 创建线程
# - 有空闲线程时，则不再创建线程
# - 没有空闲线程时，不能高于线程池的限制
# - 根据任务个数判断
# - 线程去队列中去任务
result = pool.run(func = work, args = (i,))
pool.terminate()
import contextlib
@contextlib.contextmanager
def myopen(file_path, mode):
f = open(file_path, mode, encoding = "utf-8")
try:
yield f
finally:
f.close()11. IO模型
1）阻塞IO（blocking IO）
在linux中，默认情况下所有socket都是blocking。blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block
2）非阻塞IO（non-blocking IO）
Linux下，可以通过设置socket使其变为non-blocking。
优点：能够在等待任务完成的时间里干其他事情
缺点：循环调用recv()将大幅度推高CPU占用率
所以非阻塞IO模型绝不推荐使用
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 9001))
server.listen(5)
server.setblocking(False)
while True:
try:
conn, addr = server.accept()
print(addr)
except BlockingIOError:
print("干其他事情")
server.close()from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 9001))
server.listen(5)
server.setblocking(False)
rlist = []
while True:
try:
conn, addr = server.accept()
print(addr)
rlist.append(conn)
except BlockingIOError:
del_rlist = []
for conn in rlist:
try:
data = conn.recv(1024)
if not data:
del_rlist.append(conn)
continue
conn.send(data.upper())
except BlockingIOError:
continue
except Exception:
conn.close()
del_rlist.append(conn)
for conn in del_rlist:
rlist.remove(conn)
server.close()3）多路复用IO模型
原理：select/epoll这个function会不断地轮询所负责的所有socket，当某个socket有数据到达，就通知用户进程。当用户进程调用了select，那个整个进程会被block，而同时kernel会“监听”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。
优点：单个process就可以同时处理多个网络连接的IO。使用select()的事件驱动模型志勇单线程（进程）执行，占用资源少，不消耗太多CPU，同时能够为多客户端提供服务。
缺点：select()接口并不是实现“事件驱动”的最好选择。因为当需要监测的句柄值较大时，select()接口本身需要消耗大量时间去轮询。
from socket import *
import select
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 9901))
server.listen(5)
server.setblocking(False)
rlist = [server,]
wlist = []
wdata = {}
while True:
rl, wl, xl = select.select(rlist, wlist, [], 0.5)
for sock in rl:
if sock == server:
conn, addr = sock.accept()
rlist.append(conn)
else:
try:
data = sock.recv(1024)
if not data:
sock.close()
rlist.remove(sock)
continue
wlist.append(sock)
wdata[sock] = data.upper()
except Exception:
sock.close()
rlist.remove(sock)
for sock in wl:
data = wdata[sock]
sock.send(data)
wlist.remove(sock)
wdata.pop(sock)
server.close()