day11
1、网络编程
1.1 udp协议
client端
import json
import socket
server_addr = ('127.0.0.1',9090)
sk = socket.socket(type=socket.SOCK_DGRAM)
while True:
msg = input('>>>')
dic = {'msg': msg, 'username': 'egon'}
send_msg = json.dumps(dic).encode('utf-8')
sk.sendto(send_msg, server_addr)
msg,server_addr = sk.recvfrom(1024)
msg_dic = json.loads(msg.decode('utf-8'))
print('消息来自%s : %s' % (msg_dic['username'], msg_dic['msg']))
sk.close() server端
import json
import socket
sk = socket.socket(type= socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',9090))
while True:
# 不能先发信息
msg,client_addr = sk.recvfrom(1024) # UDP协议接收信息的方法
# {'msg':消息,'username':发送消息的人}
msg_dic = json.loads(msg.decode('utf-8'))
print('消息来自%s : %s'%(msg_dic['username'],msg_dic['msg']))
msg = input('>>>')
dic = {'msg':msg,'username':'server'}
send_msg = json.dumps(dic).encode('utf-8')
sk.sendto(send_msg,client_addr)
sk.close()
# UDP协议
# 无连接，可以多个客户端发送
# 快
# 不可靠
# 面向数据包的传输 只能发短消息1.2 socketserver
server端
import socketserver
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
conn = self.request
addr = self.client_address
while True:
conn.send(b'hello')
print(conn.recv(1024),addr[1])
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1',9090),Myserver)
server.serve_forever()client端没有变化
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9090))
while True:
print(sk.recv(1024))
sk.send(b'bye')
sk.close()2、并发编程
2.1 操作系统
多道操作系统: 数据隔离 资源分配
在一台机器读数据进CPU的时候
这台机器还能同时计算另外一个程序
CPU在两个程序之间切换??
遇见不需要CPU工作的代码的时候
IO操作 输入输出
time.sleep() input f.read sk.accept sk.recv
print f.write sk.send
提高了CPU的工作效率分时系统 反而降低了效率,但是提高了用户体验
A 3min 6min
B 24h 24h3min
短作业优先算法
CPU工作的时间 分成很小很小的时间片
所有的作业在操作系统的调度下轮流被CPU执行
纯浪费效率CPU个数提高
多个程序在运行
运行中的程序 - 进程
# 进程
# 进程是计算机中资源分配的最小单位
# PID process id 进程的id
# ppid parent porcess id 父进程2.2、 进程的并行与并发
并行 : 并行是指两者同时执行，比如赛跑，两个人都在不停的往前
跑；（资源够用，比如三个线程，四核的CPU ）
并发 : 并发是指资源有限的情况下，两者交替轮流使用资源，比如一
段路(单核CPU资源)同时只能过一个人，A走一段后，让给B，B用完继
续给A ，交替使用，目的是提高效率。
区别:
并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执
行，这就要求必须有多个处理器。
并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服
务器同时处理多个session。2.3 同步异步阻塞非阻塞
同步
做完一件事情 再做另外一件事情
异步
做一件事情的时候 可以再做另一件事情
一般说一个程序是异步程序，表示这个程序可以多线程并发。
阻塞
recv sleep accept input recv recvfrom
非阻塞
没有遇见上面这些阻塞的情况就是非阻塞
阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或
者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等
待消息通知时的状态角度来说的3、 在python中使用多进程
仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。
multiprocessing.Process
process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。
import time
from multiprocessing import Process
def f(name):
print('hello', name)
print('我是子进程')
if __name__ == '__main__': # if __name__ == '__main__': 在win上必须写,在其他操作系统上可不写
p = Process(target=f, args=('bob',))
p.start()
time.sleep(1)
print('执行主进程的内容了')
# 主进程和子进程的异步 并发效果、
# 主进程会等待子进程结束之后在结束, 为什么主进程要等待子进程结束
主进程要回收子进程的资源进阶，多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的）
import time
from multiprocessing import Process
def f(name):
print('hello', name)
time.sleep(1)
if __name__ == '__main__':
p_lst = []
for i in range(5):
p = Process(target=f, args=('bob',))
p.start()
p_lst.append(p)
# [p.join() for p in p_lst]
print('父进程在执行')
主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）除了上面这些开启进程的方法，还有一种以继承Process类的形式开启进程的方式
import os
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
print(os.getpid())
print('%s 正在和女主播聊天' %self.name)
p1=MyProcess('wupeiqi')
p2=MyProcess('yuanhao')
p3=MyProcess('nezha')
p1.start() #start会自动调用run
p2.start()
# p2.run()
p3.start()
p1.join()
p2.join()
p3.join()
print('主线程')守护进程
import os
import time
from multiprocessing import Process
def func2():
print('func2 before', os.getpid())
time.sleep(5)
print('func2 after',os.getpid())
def func():
print('in func before', os.getpid())
time.sleep(3)
print('in func after',os.getpid())
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 将p设置为一个守护进程
p.start()
p = Process(target=func2)
p.start()
time.sleep(1)
print('主进程',os.getpid())
# 主进程的代码执行完毕之后 守护进程就自动结束了 - 守护进程1、 先把QQ这个背写出来（多进程的普通实现）
2、 多进程的类方法实现
3、 socketserver
4、join
from multiprocessing import Process
def f(name):
print('hello', name)
if __name__ == '__main__':
p_lst = []
for i in range(5):
p = Process(target=f, args=('bob',))
p.start()
p_lst.append(p)
[p.join() for p in p_lst]
print('父进程在执行')类的join
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print(self.name)
if __name__ == '__main__':
p = MyProcess('houbinglei')
p.start()
p.join()
print('主程序')5、daemon
import time
from multiprocessing import Process
def f(name):
print('hello', name)
time.sleep(2)
if __name__ == '__main__':
p_lst = []
for i in range(5):
p = Process(target=f, args=('bob',))
p.daemon = True
p.start()
p_lst.append(p)
# [p.join() for p in p_lst]
print('父进程在执行')6、锁
import json
import time
from multiprocessing import Process,Lock
def search(i):
with open('ticket_db.py') as f:
ticket = json.load(f)
time.sleep(0.1)
print('%s查询余票 : '%i,ticket['count'])
def buy_ticket(i,lock):
lock.acquire()
with open('ticket_db.py') as f:
ticket = json.load(f)
time.sleep(0.1)
if ticket['count'] > 0:
ticket['count'] -= 1
print('%s购票成功'%i)
else:
print('购票失败')
time.sleep(0.1)
with open('ticket_db.py','w') as f:
json.dump(ticket,f)
lock.release()
def get(i,lock):
search(i)
buy_ticket(i,lock)
if __name__ == '__main__':
lock = Lock()
for i in range(20):
p = Process(target=get,args=(i,lock))
p.start()7、 队列
from multiprocessing import Queue,Process
# IPC Inter-process communication
def func(q):
print(q.get())
if __name__ == '__main__':
q = Queue()
p = Process(target=func,args=(q,))
p.start()
q.put(12345)
# 队列
# 帮助你保证进程之间的数据安全