1.UDP协议
-称之为：数据包协议
特点：
1.不需要建立链接
2.不需要知道对方是否收到
3.数据不安全
4.传输速度快
5.能支持并发
6.不会粘包
优点：
-传输速度快
-能支持并发
-不会粘包
缺点：
-数据不安全，容易丢失
应用场景：
早期的qq聊天室：
下面的这个例子，可以先开server或者 client 都是可以的
这个是server的服务端
import socket
# socket.SOCK_DGRAM ---->UPD协议
server = socket.socket(type = socket.SOCK_DGRAM)
#服务端需要绑定一个地址，让别人知道你在哪里
server.bind(
('127.0.0.1',9002)
)
while True:
data,addr = server.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---->server:').encode('utf-8')
client.sendto(msg, address)
——TCP协议（称为：流式协议）
优点：
-数据安全
缺点：
-传输的速度慢
-粘包
2.并发编程
2.1操作系统的发展史
1.穿孔卡片
-读取数据的速度特别慢
-CPU的利用率低
-单用户（一份代码）使用
2.批处理
-读取数据速度特别低
-CPU的利用率低
-联机（多份代码）使用
-效率还是低
3.脱机批处理（现代操作系统的设计原理）
-读取数据的速度高
-CPU的利用率高
2.2多道技术（基于单核背景下处理）
-单道：一条道走到黑-----》串行
-比如：a,b需要使用cpu，a先使用，b等待a 使用完毕后，b才可以使用
优点：程序的执行效率高
缺点：cpu的执行效率低
-多道：
-比如：a,b需要使用cpu，a先使用，b等待a，直到a进入"IO或者执行时间过长"，a会（切换+保存状态），然后b可以使用cpu，等到b执行遇到“IO或者执行时间过长”，再将cpu的权限交给a，直到2个程序结束。
多道的2个特点：
-空间上的复用：
多个程序使用一个CPU
-时间上的复用;
切换+保存状态
1.当执行遇到IO时，操作系统会把CPU的执行权限剥夺
优点：cpu的执行效率高
2.当执行程序执行时间过长时，操作系统会将cpu的执行权限剥夺。
缺点：程序的执行效率低
2.3并发和并行
-串行：
-并发：
在单核（一个cpu）情况下，当执行2个a，b程序时，a先执行，当a 遇到IO时，b开始争夺cpu的执行权限，再让b执行，他们看起来像是同时运行。
-并行：
在多核（多个cpu）的情况下，当执行2个程序时，a和b同时执行，他们是真正意义上的同时运行。
面试问题：在单核情况下能否实现并行？ 不行
2.4进程
1.什么是进程？
进程是一个资源单位。
2.进程和程序
-程序：一堆代码文件
-进程：执行代码的过程，称之为进程
-3.进程的调度
1.先来先服务的调度算法
-比如：a,b 若a先来，则让a先服务，待a服务完毕后，b再服务
-缺点：执行效率低
2.短作业优先调度算法：
-执行时间越短，则优先调度
-缺点：
导致执行时间长的出程序，需要等待所有时间短的程序执行完毕后，才能执行。
3.时间片轮转法
-比如：同时有10个程序需要执行，操作系统会给你10秒，然后时间片轮法会将10秒分成10等分 分给10个程序，如果有些程序的需要的时间超过1秒，则会继续排队，跟下一批的同时程序，按照时间片轮法去分配执行。
4.多级反馈队列：
1级队列：优先级最高，先执行队列中的程序；
2级队列：优先级以此类推
.....
现代操作系统的进程调度法：时间片轮法+多级反馈队列
2.5同步和异步
同步与异步指的是”提交任务的方式“
-同步（串行）
2个程序a，b程序都要提交并执行，假如a先提交执行，b必须等a执行完毕后，才能提交任务。
-类似于单道，相当于同步提交任务
-异步（并发）
2个程序a，b程序都要提交并执行，假如a先提交并执行，b不需要等a执行完毕，就可以直接提交任务。
类似于多道，相当于异步提交任务（看来像是同时运行）
-并行
在多核的情况，多个任务同时运行（真正意义上的同时运行）
2.6阻塞和非阻塞
-阻塞（等待）
-凡是遇到io的都会阻塞
IO： input()、 output() 、time.sleep() 、文件的读写、 数据的传输
-非阻塞（不等待）
除了 IO都是非阻塞，（比如从1+1到100万）
2.7进程的三种状态
-就绪态
-同步和异步
-运行态：程序的执行时间过长------->将程序返回给就绪态
-非阻塞
-阻塞态：
-遇到IO
面试题：阻塞和同步是一样的吗？非阻塞和异步是一样的？ ----->不一样
-同步和异步：提交任务的方式
-阻塞和非阻塞：进程的状态
-异步非阻塞：------>cpu的利用率最大化 ，最大化提高程序的执行效率
2.8创建进程的2种方式
1种 直接调用Process
from multiprocessing import Process
import time
#方式一：直接调用Process
def task():
print(f'start...{1}')
time.sleep(1)
print(f'end...{1}')
if __name__ == '__main__':
obj = Process(target = task)#target 是一个任务》》创建子进程
obj.start()###告诉操作系统去创建一个子进程
print('正在执行当前的进程')###print 这个是主进程，但是有了process
个模块，新开辟一个名称空间，放置def task函数的子进程，等主进程节水了，才可以执行子进程
>>>>>>>>>>>>>>>>>>>>>>>>>>>
正在执行当前的进程
start...1
end...1
join（）等待子进程结束了，再结束主进程
from multiprocessing import Process
import time
#方式一：直接调用Process
def task():
print(f'start...{1}')
time.sleep(1)
print(f'end...{1}')
if __name__ == '__main__':
obj = Process(target = task)
obj.start()
obj.join()##告诉主进程等待子进程结束后，在结束
print('正在执行当前的进程')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
start...1
end...1
正在执行当前的进程
#方式一：直接调用Process
def task(name):
print(f'start...{name}')
time.sleep(1)
print(f'end...{name}')
if __name__ == '__main__':
obj1 = Process(target = task,args =('abc',))
obj2 = Process(target = task,args =('def',))
obj3 = Process(target = task,args =('ghk',))
obj1.start()
obj2.start()
obj3.start()
#obj.join()##告诉主进程等待子进程结束后，在结束
print('正在执行当前的进程')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>####下面这个是异步操作
正在执行当前的进程
start...def
start...ghk
start...abc
end...ghk
end...def
end...abc
加了join的异步提交
from multiprocessing import Process
import time
#方式一：直接调用Process
def task(name):
print(f'start...{name}')
time.sleep(1)
print(f'end...{name}')
if __name__ == '__main__':
obj1 = Process(target = task,args =('abc',))
obj2 = Process(target = task,args =('def',))
obj3 = Process(target = task,args =('ghk',))
obj1.start()
obj2.start()
obj3.start()
obj1.join()##告诉主进程等待子进程结束后，在结束
obj2.join()##告诉主进程等待子进程结束后，在结束
obj3.join()##告诉主进程等待子进程结束后，在结束
print('正在执行当前的进程')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
start...abc
start...ghk
start...def
end...abc
end...ghk
end...def
正在执行当前的进程
for 循环做的异步
from multiprocessing import Process
import time
#方式一：直接调用Process
def task(name):
print(f'start...{name}')
time.sleep(1)
print(f'end...{name}')
if __name__ == '__main__':
list1 = []
for line in range(10):
obj = Process(target=task, args=('abc',))
obj.start()
list1.append(obj)
for obj in list1:
obj.join()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
start...abc
start...abc
start...abc
start...abc
start...abc
start...abc
start...abc
start...abc
start...abc
start...abc
end...abc
end...abc
end...abc
end...abc
end...abc
end...abc
end...abc
end...abc
end...abc
end...abc
主进程
第二种的方式
from multiprocessing import Process
import time
class Myprocess(Process):
def run(self):####这个是run是重写Process内部的方法，只有这样操作 ，才能执行这个进程
print(f'start...{self.name}的子进程')
time.sleep(2)
print(f'end...{self.name}的子进程')
if __name__ == '__main__':
list1 =[]
for line in range(5):
obj = Myprocess()
obj.start()
list1.append(obj)
for obj in list1:
obj.join()
print('主进程...')
>>>>>>>>>>>>>>>>>>>>>>>>>>>
start...Myprocess-3的子进程
start...Myprocess-4的子进程
start...Myprocess-1的子进程
start...Myprocess-2的子进程
start...Myprocess-5的子进程
end...Myprocess-3的子进程
end...Myprocess-1的子进程
end...Myprocess-2的子进程
end...Myprocess-4的子进程
end...Myprocess-5的子进程
主进程...
主进程...
主进程...
主进程...
主进程...