day11_雷神_udp、多进程等

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)

# 队列
# 帮助你保证进程之间的数据安全