软件开发架构
C/S架构
客户端与服务端
作为服务端必备的条件；
24小时不间断提供服务
固定的IP地址
能够同时服务多个人
B/S架构
网页端与服务器端
两个架构的优劣势：
C/S架构：
优势：不同公司独立开发，能够高度定制化客户端
劣势：需要下载
B/S架构：
优势：不需要下载，可以直接访问
劣势：基于网页，需要遵守很多规则
编程协议之OS协议
1.什么是网络编程
基于网络编写代码，实现远程交互
2.学习网络编程的目的
能够开发C/S架构
3.网络编程的必备条件
数据的远程交互
OSI七层协议
"""OSI七层协议规定了所有计算机在远程数据交互的时候必须经过相同的处理流程，在制造过程中必须拥有相同的功能硬件"""
OSI七层协议：
应用层
表示层
会话层
传输层
网络层
数据链路层
物理层
演变的五层协议：
应用层
传输层
网络层
数据链路层
物理层
"""
发送消息：数据由上往下传递
接收消息：数据由下往上传递
"""
OSI七层协议之物理层
主要用于确保计算机之间的物理连接介质，接收的数据（bytes也就是二进制）
OSI七层协议之数据链路层
1.规定了电信号的分组方式
2.以太网协议
规定了每台计算机都必须携带一张网卡，网卡上有一串数据
该数字是独一无二的，相当于计算机的身份证
数字的特征：12位的16进制，有厂商号和流水号组成
该数字也被称为MAC地址、以太网地址
OSI七层协议之网络层
IP协议:规定了所有接入互联网的计算机都必须有一个IP地址，是动态可以修改的，不同场所的IP地址也是不同的
IP地址的特征：
IPV4：点十分进制（32位的二进制）
0.0.0.0 到255.255.255.255
IPV6：2的128次方减1 号称能够给气球上的每一粒沙分配IP地址
OSI七层协议之传输层
PORT协议（端口协议）
用来标识一台计算机上面的某一个应用程序
范围：0-65535
特征：动态分配
建议：
0-1024 操作系统默认端口
1025-8000 常见软件的端口号
8001-65535 可以使用
URT：统一资源定位符（网址）
网址的本质是由IP地址和PORT地址池组成的
IP+PORT：能够定位全世界独一无二的一台计算机上面的某一个应用程序
域名解析：将网址解析成IP+PROT
TCP协议：
也称为可靠协议、流式协议
造成数据不容易丢失的原因不是因为有双向通道而是因为有反馈机制
三次握手建立连接，四次挥手断开连接
UDP协议：
不可靠协议、数据报协议
直接发送，没有三次握手，四次挥手
OSI七层协议之应用层
应用层相当于程序员自己写的应用程序，里面的协议非常多
网络相关专业名字
1.交换机
能够将所有接入交换机的计算机彼此互连起来
2.广播
局域网中某台计算机首次与其他计算机交互，需要朝交换机吼一嗓子
3.单播
在广播之后，某台计算机回应广播的计算机
4.广播风暴
同一时间，多台计算机同时发起广播
5.局域网
由多台计算机与单个交互机组成的网络
在局域网中可以通过MAC地址通讯
6.广域网
多个局域网组成的
7.互联网
多个广域网组成的
8.路由器
可以实现不同局域网之前的数据交互
socket模块
如果我们需要编写基于网络数据交互的程序，意味着我们需要自己通过代码来控制我们学习的OSI七层协议
socket类似性与操作徐彤，封装了丑陋复杂的接口提供简单快捷的接口
socket也叫套接字：
基于文件类型的套接字家族（单机）AF_UNIX
基于网络类型的套接字家族（网络）AF_INET
代码展示：
客户端
import socket
client = socket.socket() # 建立客户端对象
client.connect(('127.0.0.1', 8080)) # 连接服务端
while True:
msg = input('请输入向服务端发送的内容>>>:').strip()
client.send(msg.encode('utf8')) # 发送二进制
date = client.recv(1024) # 接收服务端的消息
print(date.decode('utf8'))
服务端
import socket
server = socket.socket() # 产生服务端对象
server.bind(('127.0.0.1', 8080)) # 建议服务端地址
server.listen(5) # 建立半连接池
sock, addr = server.accept() # 等待通道建立，返回值是通道号和IP地址
# 服务端是用通道来接收消息的
while True:
date = sock.recv(1024) # 括号里面添加的是接收消息的长度
# 接收到的消息是二进制，需要转换
print(date.decode('utf8'))
msg = input('请输入回复客户端的内容>>>:').strip()
sock.send(msg.encode('utf8'))
半连接池的概念
server.listen(5)
当有多个客户端来连接的情况下，我们可以设置等待数量（不考虑并发问题）
假设服务端一次只能有一个人的清下
半连接池可以把其余的人全部拦住，让他们等待访问，避免洪水攻击
黏包现象及解决办法
黏包现象
1.客户端连续发送3次消息
2.服务端连续接收3次消息
会发现客户端的3次消息会变成一次性接收
黏包现象产生的原因:
1.不知道每次数据具体有多大
2.TCP也称为流式协议，会像流水一样绵绵不绝（会针对数据较小发送间隔比较短的数据打包一次性付阿松）
struct模块
模块的作用：将数据的长度打包成固定的长度，也可以通过该模块将打包的长度解析出来真实的长度
解决黏包
客户端代码展示：
import socket
import os
import json
import struct
client = socket.socket() # 建立客户端对象
client.connect(('127.0.0.1', 8080)) # 连接服务端
# 先判断真实数据的长度
file_size = os.path.getsize(r'C:\pythonProject\ATM\a.txt')
# 将真实的数据放入数据字典中
file_dict = {'file_name': 'a.txt',
'file_size': file_size}
# 将字典转json字符串转二进制，字典无法直接转二进制
file_bytes_dict = json.dumps(file_dict).encode('utf8')
# 利用struct模块将字典的长度变成固定的格式
file_struct_dict = struct.pack('i', len(file_bytes_dict))
# 发送4个字节的打包后长度
client.send(file_struct_dict) # 已经是二进制了不需要转
client.send(file_bytes_dict) # 二进制的字典数据
# 文件数据内容需要打开读取才能够发送，用二进制的方式打开
with open(r'C:\pythonProject\ATM\a.txt', 'rb') as f:
client.send(f.read())
服务端代码展示：
import socket
import struct
import json
server = socket.socket() # 产生服务端对象
server.bind(('127.0.0.1', 8080)) # 建议服务端地址
server.listen(5) # 建立半连接池
sock, addr = server.accept() # 等待通道建立，返回值是通道号和IP地址
# 第一次接收的打包后的4个字节的字典长度
file_struct_dict = sock.recv(4) # 括号里面添加的是接收消息的长度
# 通过struct模块解析出来字典的长度,注意解析是个元组，索引0
file_bytes_len = struct.unpack('i', file_struct_dict)[0]
# 根据字典的长度，来接收字典的数据
file_bytes_dict = sock.recv(file_bytes_len)
# 反序列化字典，得到真实的字典数据
file_dict = json.loads(file_bytes_dict)
# 根据真实字典的数据获取真实数据的大小
file_size = file_dict.get('file_size')
with open(r'a.xtx', 'wb') as f:
f.write(sock.recv(file_size))
并发编程
"""计算机中真正干活的是CPU"""
操作系统发展史：
1.穿孔卡片
2.联机批处理系统
3.脱机批处理系统
操作系统的发展史就是CPU利用率提升的过程
单道技术
所有的程序都需要排队执行，过程不能重合
多道技术
切换：
计算机的CPU在两种情况下会切换
1.程序有IO操作
包含：输入、输出、input、time.sleep、read、write
2.程序长时间占用CPU
保存状态：
每一次切换之前都会保存当前操作的状态
进程理论
进程与程序的区别：
程序：一堆死代码（还没有被运行起来）
进程:正在运行的程序（死代码被运行起来了）
进程的调度算法（重要）：
1.FCFS(先来先服务)
对短作业不友好
2.短作业优先调度
对长作业不友好
3.时间片轮转法+多级反馈队列
将时间均分，然后根据进程时间长短再分多个等级
等级越靠下表示耗时越长，每次分到的时间越多，但是优先级越低
进程的三状态
就绪态
运行态
阻塞态
并行与并发
并行
多个程序同时执行，必须要有多个CPU参与
并发
看上去像多个程序同时执行，单个CPU可以实现
多进程
同步与异步
用来表达任务的提交方式
同步
提交完任务之后需要原地等待任务的返回结果，期间不做任何事
异步
提交完任务之后不原地等待任务的返回结果，直接去做其他的事情
阻塞与非阻塞
阻塞
阻塞态
非阻塞
运行态、就绪态
综合使用
同步阻塞
同步非阻塞
异步阻塞
异步非阻塞
创建进程的多种方式
1.鼠标双击软件图标运行
2.python代码创建进程
创建子进程的方式1：
from multiprocessing import Process
import time
def task(name):
print('task is running', name)
time.sleep(3)
print('task is over', name)
if __name__ == '__main__':
p1 = Process(target=task, args=('jason',)) # 产生一个对象,参数要用元组括起来
p1.start() # 异步操作告诉操作系统创建一个新的进程 并在该进程中执行task函数
task('tom') # 这里是同步操作，进行主进程的操作，然后打印主，子进程执行下来立马就主进程执行
print('主') # 启动子进程的同时会执行下面的操作，不会等子进程的结果
进程间数据隔离
同一台计算机上的所个进程数据是严格意义上的物理隔离
进程的join方法
join方法就是让主进程等待子进程执行结束
from multiprocessing import Process
import time
def task(name, n):
print('%s is running' % name)
time.sleep(n)
print('%s in over' % name)
if __name__ == '__main__':
p1 = Process(target=task, args=('jason', 5))
p2 = Process(target=task, args=('jason', 6))
p3 = Process(target=task, args=('jason', 8))
star_time = time.time()
p1.start() # 创建子进程p1
p1.join() # 主程序等待子代码运行结束再执行
IPC机制
IPC:进程间通信
消息队列：储存数据的地方，所有人都可以存，也都可以取
from multiprocessing import Queue
q = Queue(3) # 括号内可以指定存数据的个数
q.put(111) # 往消息队列对方数据.
print(q.full()) # 判断消息队列是否已满False不满
q.put(222)
q.put(333)
print(q.full()) # True,满了
# 从消息队列中取出数据
print(q.get())
print(q.get())
print(q.empty()) # 判断消息队列是否为空。False不为空
print(q.get())
print(q.empty()) # 判断消息队列是否为空。True为空
print(q.get_nowait())
"""
full() empty() 在多进程中都不能使用!!!
"""
子进程在消息队列中添加消息：
from multiprocessing import Queue, Process
def product(q):
q.put('子进程p添加的数据') # 添加数据
def consumer(q):
print('子进程获取队列中的数据', q.get()) # 获取数据
if __name__ == '__main__':
q = Queue() # 产生消息队列
p1 = Process(target=consumer, args=(q,))
p2 = Process(target=product, args=(q,))
p1.start() # 创建子进程p1
p2.start() # 创建子进程p2
print('主')
进程对象的多种方法
1.如何查看进程号
from multiprocessing import Process, current_process
current_process() # 查看进程
current_process().pid # 获取进程号
import os
os.getpid() # 获取进程号
os.getppid() # 获得子进程的父进程
2.终止进程
p1.terminate()
ps:计算机操作系统都有对应的命令可以直接杀死进程
3.判断进程是否存货
p1.is_alive()
4.start() # 自动子进程
5.join() # 让主程序等待子进程结束才执行
守护进程
守护进程会随着守护的进程结束而立刻结束
from multiprocessing import Process
import time
def task(name):
print('德玛西亚:%s' % name)
time.sleep(3)
print('德玛西亚;%s' % name)
if __name__ == '__main__':
p1 = Process(target=task, args=('jason',))
p1.daemon = True # 将子进程绑定为主进程的守护进程
p1.start() # 启动子进程
time.sleep(1)
print('主进程结束')
"""德玛西亚:jason
主进程结束
子进程的另一个打印操作未执行，因为主进程结束了，所以作为守护进程的子进程也直接结束
"""
僵尸进程与孤儿进程
僵尸进程
进程执行完毕后并不会立刻销毁所有的数据，会有一些信息短暂保留下来
比如:进程号、进程执行时间、进程消耗功率等给父进程查看
ps:所有的进程都会变成僵尸进程
孤儿进程
子进程正常运行，父进程意外死亡，操作系统针对孤儿进程会派遣福利院管理