udp协议与进程
一、udp协议
#- sever
import socket
#socket.SOCK_DGRAM--->UPD协议
sever = socket.socket(type=socket.SOCK_DGRAM)
#服务端需要绑定一个地址，让别人知道你在哪里
sever.bind(
('127.0.0.1', 9002)
)
while True:
#发送数据给服务端的用户地址
data, addr = sever.recvfrom(1024)
print(addr)
print(data.decode('utf-8'))
#- client
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
address = ('127.0.0.1', 9002)
while True:
msg = input('client---->sever:').strip().encode('utf-8')
client.sendto(msg, address)
('127.0.0.1', 57697)
热巴
('127.0.0.1', 59959)
热巴真美啊
('127.0.0.1', 59960)
热巴亚峰啊
二、理论知识
1、udp协议（了解）
称之为数据包协议
特点：
1） 不需要建立链接
2） 不需要知道对方是否收到
3） 数据不安全
4） 传输速度快
5） 能支持并发
6） 不会粘包
7） 无需先启动服务端再启动客户端
优点：
- 传输速度快
- 能支持并发
- 不会粘包
缺点：
- 数据不安全，容易丢失
应用场景：早期的QQ聊天室
- tcp协议（称为流式协议）
优点：
- 数据安全
缺点：
- 传输速度慢
- 粘包
面试可能会问：tcp与udp的区别，简述优缺点即可（*******）
2、并发编程
1）操作系统发展史
- 1.1 穿孔卡片
- 读取数据速度特别慢
- CPU的利用率极低
- 单用户（一份代码使用）
- 1.2 批处理
- 读取数据速度特别慢
- CPU的利用率极低
- 联机（多份代码使用）
- 效率还是很低
- 1.3 脱机批处理（现代操作系统的设计原理）
- 读取数据速度高
- CPU的利用率提高
2） 多道技术（基于单核背景下产生的）：
- 单道：一条道走到黑 ---> 串行
- 比如：a,b需要使用CPU，a先使用，b等待a使用完毕后才能使用CPU
- 多道：（*******）
- 比如：a,b需要使用CPU,a先使用,b等待a,直到a进入“io或执行时间过长”
a会（切换 + 保存）,然后b可以使用CPU,待b执行遇到“io或执行时间过长”
再将CPU执行权限交给a,直到两个程序结束
- 空间的复用（*******）
多个程序使用一个CPU
- 时间上的复用（*******）
切换 + 保存状态
1）当执行程序遇到io时，操作系统会将CPU的执行权限剥夺。
优点：
- CPU的执行效率提高
2）当执行时间过长时，操作系统会将CPU的执行权限剥夺
缺点：
- 程序的执行效率低
- 并发与并行；（*******）
- 并发（一个人）：
在单核（一个CPU）情况下，当执行两个a,b程序时，a先执行，当a遇到io时，b开始争抢CPU的权限，再让b执行，他们看起来像同时运行。
- 并行（两个或多个人）：
在多核（多个CPU）的情况下，当执行两个a,b程序时，a与b同时执行。他们是真正意义上的运行。
面试题：在单核情况下能否实现并行？答：不行
3）进程
1、什么是进程？
进程是一个资源单位
2、进程与程序：
- 程序：一堆代码文件
- 进程：执行代码的过程，称之为进程
3、进程调度（了解）
1）先来先服务调度算法（了解）
- 比如程序：a,b,若a先来，则让a先服务，待a服务完成以后，b再服务。
- 缺点：执行效率低
2）短作业优先调度算法优先（了解）
- 执行时间短，则先调度。
- 缺点：导致执行时间长的程序，需要等待所有短时间的程序执行完毕后，才能执行
现代操作系统的进程调度算法：时间片轮法 + 多级反馈队列（知道）
3）时间片轮法
- 比如同时有10个程序需要执行，操作系统会给你10秒，然后时间片轮法会将10秒分成10等分。
4）多级反馈队列：
1级队列：优先级最高，先执行队列中的程序
2级队列：优先级其次
3级队列：以此类推
4）同步与异步（*******）
同步与异步 指的是 “提交任务的方式”。
同步（相当于串行）：
两个a,b程序都需要提交并执行，假如a先提交执行，b必须等a执行完毕后，才能提交任务。
异步（相当于并发）：
两个a,b程序都需要提交并执行，假如a先提交并执行，b无需等a执行完毕，就可以直接提交任务。
5）阻塞与非阻塞（*******）：
- 阻塞（等待）：
- 凡是遇到io都会阻塞
- io：
input（）
output（）
time.sleep(3)
文件的读写
数据的传输
- 非阻塞（不等待）：
- 除了io都是非阻塞（比如：从1+1开始计算到100万）
6）进程的三种状态（*******）：
- 就绪态：
-同步与异步
- 运行态：程序的执行时间过长 ---->将程序返回给就绪态
-非阻塞
- 阻塞态：
- 遇到io
面试题：阻塞与同步是一样的吗？非阻塞与异步是一样的吗？
- 同步与异步：提交任务的方式
- 阻塞非阻塞：进程的状态
- 异步与非阻塞：--->CPU的利用率最大化
7）创建进程的两种方式：
三、同步演示
import time
def func():
print('start...')
time.sleep(3)
print('end...')
if __name__ == '__main__':
#任务一：
func()
#任务二：
print('程序结束')
#同步执行：任务一执行完以后才会执行任务二
start...
end...
程序结束
from multiprocessing import Process
import time
#方式一：直接调用Process
def task(): #任务 #name== 'jason_sb'
print(f'start....的子进程')
time.sleep(3)
print(f'end...的子进程')
if __name__ == '__main__':
#target = 任务（函数地址）---> 创建一个子进程
#异步提交三个任务
p_obj = Process(target=task)
p_obj.start() #告诉操作系统，去创建一个子进程
p_obj.join() #告诉操作系统，等待子进程结束以后，再结束,此时相当于串行
print('正在执行当前主进程')
start....的子进程
end...的子进程
正在执行当前主进程
# #异步提交三个任务
# #方式一：直接调用Process
#
# def task(name): #任务 #name== 'jason_sb'
#
# print(f'start....{name}的子进程')
# time.sleep(3)
# print(f'end...{name}的子进程')
#
# if __name__ == '__main__':
# #target = 任务（函数地址）---> 创建一个子进程
# #异步提交三个任务
# p_obj1 = Process(target=task, args=('jason_sb',))
# p_obj2 = Process(target=task, args=('sean_sb',))
# p_obj3 = Process(target=task, args=('tank_sb',))
#
#
# p_obj1.start() #告诉操作系统，去创建一个子进程
# p_obj2.start() #告诉操作系统，去创建一个子进程
# p_obj3.start() #告诉操作系统，去创建一个子进程
#
#
# print('正在执行当前主进程')
#
# # start....jason_sb的子进程
# # start....sean_sb的子进程
# # start....tank_sb的子进程
# # end...jason_sb的子进程
# # end...sean_sb的子进程
# # end...tank_sb的子进程
#同步提交三个
def task(name): #任务 #name== 'jason_sb'
print(f'start....{name}的子进程')
time.sleep(3)
print(f'end...{name}的子进程')
if __name__ == '__main__':
task(1)
task(2)
task(3)
# start....1的子进程
# end...1的子进程
# start....2的子进程
# end...2的子进程
# start....3的子进程
# end...3的子进程
异步执行多个进程
def task(name): #任务 #name== 'jason_sb'
print(f'start....{name}的子进程')
time.sleep(3)
print(f'end...{name}的子进程')
if __name__ == '__main__':
list1 = []
for line in range(10):
p_obj = Process(target=task, args=('jason_sb', )) #target后面接的是要调用的对象，即子进程要执行的任务，而args表示调用对象的位置参数元组
p_obj.start()
list1.append(p_obj)
for obj in list1:
obj.join()
print('主进程')
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
start....jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
end...jason_sb的子进程
主进程
#方式二：
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self): # 注意：这里必须重写run，并且只能是run而不能是其他函数名
print(f'start...{self.name}的子进程')
time.sleep(3)
print(f'end...{self.name}的子进程')
if __name__ == '__main__':
list1 = []
for line in range(10):
obj = MyProcess()
obj.start()
list1.append(obj)
for obj in list1:
obj.join()
print('主进程...')
# start...MyProcess-1的子进程
# start...MyProcess-2的子进程
# start...MyProcess-4的子进程
# start...MyProcess-5的子进程
# start...MyProcess-3的子进程
# start...MyProcess-6的子进程
# start...MyProcess-8的子进程
# start...MyProcess-7的子进程
# start...MyProcess-9的子进程
# start...MyProcess-10的子进程
# end...MyProcess-1的子进程
# end...MyProcess-2的子进程
# end...MyProcess-4的子进程
# end...MyProcess-5的子进程
# end...MyProcess-3的子进程
# end...MyProcess-6的子进程
# end...MyProcess-7的子进程end...MyProcess-8的子进程
# end...MyProcess-9的子进程
# end...MyProcess-10的子进程
# 主进程...