day32

Posted on 2019-11-19 10:34  猪宝店幼儿园  阅读(83)  评论(0)  编辑  收藏  举报

目录

回顾

软件开发架构:
C/S:
Client: 客户端
Server: 服务端

优点:
占用网络资源少,软件的使用稳定

缺点:
服务端更新后,客户端也得跟着跟新.
需要使用多个软件,需要下载多个客户端

B/S:
Browser: 浏览器(客户端)
Server: 服务端

服务端与客户端作用:
服务端: 24小时不间断提供服务
客户端: 需要体验服务端时,再去连接服务端,并享受服务

一 网络编程:
1.互联网协议OSI七层协议
1)应用层
2)表示层
3)会话层
4)传输层
5)网络层
6)数据链路层
7)物理连接层

物理连接层
基于电信号发送二进制数据.

数据链路层

  1. 规定好电信号的分组方式
  2. 必须要有一块网卡:
  • mac地址:
    12位唯一的16进制字符串
  • 前6位: 厂商号
  • 后6位: 流水号
    以太网协议:
    在同一个局域网内通信.
    单播
    1对1吼
    广播
    多对多吼
    广播风暴:
    不能跨局域网通信
    网络层
    ip: 定位局域网的位置
    port: 唯一标识一台计算机上一个应用程序.
    arp协议:
    将mac地址获取,并解析成ip和port.
    传输层
    TCP
    特点:
    TCP协议称之为流式协议.

若想要通信,必须建立连接,并建立双向通道.
三次握手,四次挥手
三次握手建连接
客户端往服务端发送请求建立通道
服务端要确认客户端的请求,并往客户端也发送请求建立通道
客户端接收到服务端建立连接的请求,并返回确认
建立双向通道
双向通道:
反馈机制
客户端往服务端发送请求获取数据,服务端务必返回数据,客户端确认收到.
反则会反复发送,一直到某个时间段内,会停止发送
四次挥手断连接
C往S发送断开连接请求,S返回确认收到
S需要再次发送断开连接请求
C返回确认收到
最终确认断开连接
UDP
1)数据不安全
2)不需要建立双向通道
3)传输速度快
4)不会有粘包问题
5)客户端发送数据,不需要服务端确认收到,爱收不收

TCP与UPD的区别:
TCP: 比喻成在打电话
UDP: 比喻成发送短信

应用层
ftp
http:
可以携带一堆数据

http + ssl

2.socket
socket用来写套接字客户端与服务端的模块,内部帮我们封装好了7层协议需要做的事情.

3.手撸socket套接字模板

  • 服务端:
    import socket
    server = socket.socket()
    server.bind(
    (ip, port)
    ) # 绑定手机号
    server.listen(6) # 半连接池: 可以接待7个客户端

监听连接

conn, addr =server.accept()

接收消息

data = conn.recv(1024)

发送消息

conn.send('消息内容'.encode('utf-8'))

客户端:
import socket
client = socket.socket()
client.connect(
(ip, port)
)
发送消息
client.send()
接收消息
client.recv(1024)
4.subprocess(了解)
用来通过代码往cmd创建一个管道,并且发送命令和接收cmd返回的结果.
import subprocess
obj = subprocess.Popen(
'cmd命令',
shell=True,

接收正确结果

​ stdout=subprocess.PIPE,

接收错误结果

​ stderr=subprocess.PIPE
​ )
​ success = obj.stdout.read()
​ error = obj.stderr.read()
​ msg = success + error

5.黏包问题
1.不能确定对方发送数据的大小
2.在短时间内,间隔时间短,并且数据量小的情况, 默认将这些数据打包成一个
多次发送的数据 ---> 一次性发送

6.struct解决黏包问题
初级版:
i: 4
可以将一个数据的长度打包成一个固定长度的报头.
struct.pack('模式i', '源数据长度')
data = 'gagawagwaga'

打包成报头

headers = struct.pack('i', len(data))

解包获取数据真实长度
data = struct.unpack('i', headers)[0]

注意: 以什么方式打包,必须以什么方式解包.

升级版:
先将数据存放到字典中,将字典打包发送过去

  • 字典的好处:
  • 真实数据长度
  • 文件的描述信息
  • 发送的数据,更小

dic = {
'data_len': 1000000000000000000000046546544444444444444444444444444444444444444,
文件的描述信息
}

7.上传大文件数据

客户端

dic = {
文件大小,
文件名
}

with open(文件名, 'rb') as f:
for line in f:
client.send(line)

服务端
dic = {
文件大小,
文件名
}
init_recv = 0
with open(文件名, 'wb') as f:
while init_recv < 文件大小:
data = conn.recv(1024)
f.write(data)
init_recv += len(data)

10.socketserver(现阶段,了解)

  • 可以支持并发
    import socketserver

定义类

TCP: 必须继承BaseRequestHandler类

​ class MyTcpServer(socketserver.BaseRequestHandler):

  • handle

    内部实现了

    server = socket.socket()
    server.bind(
    ('127.0.0.1', 9527)
    )
    server.listen(5) ---

    while True:
    conn, addr = server.accept()
    print(addr)

必须重写父类的handle, 当客户端连接时会调用该方法

def handle(self):
print(self.client_address)
while True:
try:
# 1.接收消息
# request.recv(1024) == conn.recv(1024)
data = self.request.recv(1024).decode('utf-8')
send_msg = data.upper()
self.request.send(send_msg.encode('utf-8'))

    except Exception as e:
        print(e)
        break

TCP:
SOCK_STREAM
conn.recv()

UDP模板:
SOCK_DGRAM
server.recvfrom()

服务端
import socket
server = socket.socket(
type=socket.SOCK_DGRAM
)
server.bind(
(ip, port)
)
data, addr = server.recvfrom(1024)
server.sendto(data, addr)

客户端
import socket
client = socket.socket(
type=socket.SOCK_DGRAM
)
ip_port = (ip, port)

client.sendto(data, ip_port)

data, _ = client.recvfrom(1024)
print(data)

二 并发编程
12.多道技术

  • 单道

多道: 切换 + 保存状态
空间上的复用
支持多个程序使用

时间上的复用
遇到IO操作就会切换程序
程序占用CPU时间过长切换
13.并发与并行
并发: 看起来像同时运行: 多道技术
并行: 真正意义上的同时运行: 多核下

14.进程
进程是资源单位,没创建一个进程都会生成一个名称空间,占用内存资源.

程序与进程
程序就是一堆代码
进程就是一堆代码运行的过程

进程调度

  • 时间片轮转法
    10个进程, 将固定时间,等分成10份时间片,分配给每一个进程.

分级反馈队列
1级别:
2级别:
3级别:
进程的三个状态

  • 就绪态:
    创建多个进程, 必须要排队准备运行

运行态:
进程开始运行, 1.结束 2.阻塞

阻塞态:
当运行态遇到IO操作,就会进阻塞态.

同步与异步
提交任务的方式

  • 同步: 同步提交, 串行,一个任务结束后,另一个任务才能提交并执行.
  • 异步: 异步提交, 多个任务可以并发运行

阻塞与非阻塞
阻塞:
阻塞态
非阻塞:
就绪态
运行态
同步和异步、阻塞和非阻塞的区别。
两者是不同的概念,不能混为一谈.

创建进程的两种方式
一:
p = Process(target=任务, args=(任务的参数, ))
p.daemon = True # 必须放在start()前,否则报错
p.start() # 向操作系统提交创建进程的任务
p.join() # 向操作系统发送请求, 等所有子进程结束,父进程再结束

二:
class MyProcess(Process):
def run(self): # self == p
任务的过程

p = MyProcess()
p.daemon = True # 必须放在start()前,否则报错
p.start() # 向操作系统提交创建进程的任务
p.join() # 向操作系统发送请求, 等所有子进程结束,父进程再结束

回收进程资源的两种条件

  • 调用join让子结束后,主进程才能结束.
  • 主进程正常结束

15.僵尸进程与孤儿进程(了解)
僵尸进程: 凡是子进程结束后,PID号还在, 主进程意外死亡,没法给子进程回收资源.

  • 每个子进程结束后,都会变成,僵尸进程 (PID)

孤儿进程: 凡是子进程没有结束,但是主进程意外死亡.操作系统优化机制(孤儿院),
会将没有主,并且存活的进程,在该进程结束后回收资源.

16.守护进程
只要父进程结束,所有的子进程都必须结束.

17.互斥锁
将并发变成串行,牺牲执行效率,保证数据安全.

from multiprocessing import Lock
mutex = Lock()
加锁
mutex.acquire()
修改数据
mutex.release()

18.队列

  • FIFO队列: 先进先出
    from multiprocessing import Queue
    q = Queue(5)
    添加数据,若队列添加数据满了,则等待
    ​ q.put()
    添加数据,若队列添加数据满了,直接报错
    ​ q.put_nowait()

获取队列中的数据
q.get() # 若队列中没数据,会卡住等待
q.get_nowait() # 若队列中没数据,会直接报错

19.堆栈
LIFO

20.IPC进程间通信

  • 进程间的数据是隔离的
  • 队列可以让进程间通信
  • 把一个程序放入队列中,另一个程序从队列中获取,实现进程间数据交互

21.生产者与消费者 模型
生产者: 生产数据
消费者: 使用数据
为了保证 供需平衡.

通过队列实现, 生产者将数据扔进队列中,消费者从队列中获取数据.
可以保证一边生产一边消费.

22.线程

  • 什么是线程
  • 进程: 资源单位
  • 线程: 执行单位
  • 创建进程时,会自带一个线程

一个进程下可以创建多个线程.

使用线程的好处
节省资源的开销

进程与线程优缺点:
进程:
优点:

  • 多核下可以并行执行
  • 计算密集型下提高效率

缺点:

  • 开销资源远高于线程

线程:
优点:

  • 占用资源远比进程小
  • IO密集型下提高效率

缺点:

无法利用多核优势
23.线程间数据是共享的

  • 画图

24.GIL全局解释器锁

只有Cpython才有自带一个GIL全局解释器锁
1.GIL本质上是一个互斥锁.
2.GIL的为了阻止同一个进程内多个线程同时执行(并行)
单个进程下的多个线程无法实现并行,但能实现并发
3.这把锁主要是因为CPython的内存管理不是 "线程安全" 的.

  • 内存管理
  • 垃圾回收机制

​ 注意: 多个线程过来执行,一旦遇到IO操作,就会立马释放GIL解释器锁,交给下一个先进来的线程.

总结: GIL的存在就是为了保证线程安全的,保证数据安全

25.多线程使用的好处

  • 多线程:
    IO密集型,提高效率

多进程
计算密集型,提高效率
26.死锁现象(了解)

27.递归锁(了解,以后不用)
解决死锁现象
mutex = Lock() # 只能引用1次
mutex1, mutex2 = RLock() # 可以引用多次
+1, 只要这把锁计数为0释放该锁, 让下一个人使用, 就不会出现死锁现象.

28.信号量(绝对了解)
信号量也是一把锁, 可以让多个任务一起使用.
互斥锁:
只能让一个任务使用
信号量:
可以让多个任务一起使用.
sm = Semaphore(5) 可以让5个任务使用

29.线程队列
使用场景:
若线程间数据不安全情况下使用线程队列, 为了保证线程间数据的安全.
import queue

  • FIFO: 先进先出队列
    queue.Queue()
  • LIFO: 后进先出队列
    queue.LifoQueue()
  • 优先级队列:
  • 根据数字大小判断,判断出队优先级.
  • 进队数据是无序的
    queue.PriorityQueue()

30.event事件
可以控制线程的执行,让一些线程控制另一些线程的执行.
e = Event()

线程1
e.set() # 给线程2发送信号,让他执行

线程2
e.wait() # 等待线程1的信号

31.进程池与线程池
为了控制进程/线程创建的数量,保证了硬件能正常运行.
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor

pool1 = ProcessPoolExecutor() # 默认CPU个数
pool2 = ThreadPoolExecutor() # CPU个数 * 5
pool3 = ProcessPoolExecutor(100) # 100个
pool4 = ThreadPoolExecutor(200) # 200个

将函数地址的执行结果,给回调函数
pool4.submit(函数地址, 参数).add_done_callback(回调函数地址)

回调函数(必须接收一个参数res):
获取值
res2 = res.result()
32.协程

  • 进程: 资源单位
  • 线程: 执行单位
  • 协程: 单线程下实现并发, 不是任何的单位,是程序员YY出来的名字.

单线程下实现并发
好处是节省资源, 单线程 < 多线程 < 多进程

IO密集型下:
协程有优势

计算密集型下:
进程有优势

高并发:
多进程 + 多线程 + 协程 (Nginx)
协程的创建:
手动实现切换 + 保存状态:

  • yield

函数一直在调用next()
会不停地切换
yield不能监听IO操作的任务

gevent来实现监听IO操作
33.gevent
pip3 install gevent
from gevent import monkey
monkey.patch_all() # 设置监听所有IO
from gevent import spawn, joinall # 实现 切换 + 保存状态

实现了单线程下实现并发
s1 = spawn(任务1)
s2 = spawn(任务2)
joinall([s1, s2])
34.IO模型(了解)

  • 阻塞IO
  • 非阻塞IO
  • 多路复用IO
  • 异步IO