软件开发架构
c/s：
Client:客户端
Server:服务端
优点：
占用网路资源少，软件的使用的稳定
缺点：
服务端更新后，客户端也得跟着更新
需要使用多个软件，需要下载多个客户端
B/S：
Browser:浏览器（客户端）
Server:服务器
服务端与客户端作用：
服务端：24小时不间断提够服务
客户端:需要体验服务端时，再去连接服务端，并享受服务
一网络编程
1 互联网协议OSI七层协议
1）应用层
2）表示层
3）会话层
4）传输层
5）网络层
6）数据链路层
7）物理连接层
—物理连接层：基于电信号发送二进制数据
—数据链路层：规定好电信号的分组方式，必须有网卡
Mac地址：12位唯一的16进制字符串
前6位：厂商号
后6位：流水号
—以太网协议：在同一局域网内通信
单播：1对1对话
广播：多对多对话
—广播风暴
—不能跨局域网通信
—网络层
— ip：定位局域网的位置
—port：唯一标识一台计算机上一个应用程序
—ARP协议：将Mac地址获取，并解析程ip和port
— 传输层
—TCP特点：TCP协议称之为流失协议
若想要通信，必须建立连接，并建立双向通道
—三次握手，四次挥手
— 三次握手建连接
—客户端往服务端发送请求建立连接
—服务端要确认客户端的请求，并往客户端也发送请求建立连接
—客户端接收到服务端建立连接的请求，并返回确认
—建立双向通道
—双向通道：
—反馈机制
客户端往服务端发送请求获取数据，服务端务必返回数据，客户端确认收到
反则会反复发送，一直到某个时间段内，会停止发送
—四次挥手断连接
—客户端往服务端发送断开连接请求，服务端返回确认收到
—服务端再次发送断开连接请求
—客户端确认收到
—最终确认断开连接
—UDP
1）数据不安全
2）不需要建立双向通道
3）传输速度快
4）不会有粘包问题
5）客户端发送数据，不需要服务端确认收到，爱收不收
TCP与UDP的区别：
TCP：比喻成再打电话
UDP:比喻成发送短信
—应用层
—FTP
—HTTP:可以携带一堆数据
—HTTP + SSL
2 socket
socket用来’写套接字客户端与服务端的模块，内部帮我们封装好了7层协议需要做的事情
3 手撸socket套接字模板
服务端
import socket
server = socket.socket()
server.bind((ip,port))
server.listen(5) # 半连接池：可以接待6个客户端
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 = 'gsjfdfytaytsf'
headers = struct.pack('i' ,len(data)) # 打包成报头
data = struct.unpack('i' ,headers)[0] # 解包获取数据的真实长度
注意：以什么方式打包，必须以什么方式解包
升级版：
先将数据存放到字典中，将字典打包发送发送过去
—字典的好处：
—真实数据长度
—文件的描述信息
—发送的数据更小
dic = {'data_len':10000000000000000000000000444444444444444444,
文件的描述信息}
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,8080'))
server.listen(5) --------
while True:
conn,addr = server.accept()
print(addr)
必须重写父类的handle，当客户端连接时回调用该方法
def handle(self):
print(self.client_adddress)
while True:
try:
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 sa 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 iport Lock
mutex = Loock()
mutex.acquire() # 加锁
mutux.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.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