Day_10_总结_udp协议通信
udp协议通信
补充：
1、基于udp协议通信的套接字
2、异常处理
今日内容：
1.操作系统的发展史（*****）
1.1什么是进程
1.2如何实现并发：多道技术
2.开启进程的两种方式（*****）
3.守护进程
4.互斥锁
5.进程间通信
6.生产者消费者模型（*****）
7.什么是进程
8.开启线程的两种方式（*****）
一、基于udp协议通信的套字节
服务端：
from socket import *
server=socket(AF_INET,SOCK_DGRAM) #SOCK_STREAM=》数据报协议
server.bind(('127.0.0.1',8081))
print('start...')
while True:
data,client_addr=server.recvfrom(1024)
server.sendto(data.upper(),client_addr)
server.close()
客户端：
from socket import *
client=socket(AF_INET,SOCK_DGRAM)
while True:
msg=input('>>:').strip()
client.sendto(msg.encode('utf-8'),('127.0.0.1',8081))
data,server_addr=client.recvfrom(1024)
print(data)
client.close()
二、数据报协议的特点1
当发送的数据报大于接收数据报的缓冲大小时：
在windows系统：接收端会抛出异常
在linux系统：接收端不会抛出异常，会丢弃多余的数据
服务端：
from socket import *
server=socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM=>数据报协议
server.bind(('127.0.0.1',8081))
server.recvfrom(1024)
客户端：
from socket import *
client=socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM=>数据报协议
client.sendto(b'hello',('127.0.0.1',8081))
三 、数据报协议的特点2
udp协议没有粘包问题
udp协议能够稳定传输数据的最大数据量为512Bytes
服务端：
from socket import *
server=socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM=>数据报协议
server.bind(('127.0.0.1',8081))
data1=server.recvfrom(1024)
print('第一次接收: ',data1)
data2=server.recvfrom(1024)
print('第二次接收: ',data2)
data3=server.recvfrom(1024)
print('第三次接收: ',data3)
客户端：
from socket import *
client=socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM=>数据报协议
client.sendto(b'hello',('127.0.0.1',8081))
client.sendto(b'world',('127.0.0.1',8081))
client.sendto(b'egon',('127.0.0.1',8081))
四、补充_异常处理
'''
1.什么是异常
异常是程序发生错误的信号，程序一旦出错立即会产生一个异常，
如果该异常没有被应用程序处理，那么就抛出来，程序的运行随即终止
程序的错误：
1.语法上的错误：在程序运行前立即改正
2.逻辑上的错误：
2.1如果可以预知错误条件的发生，应该使用if判断去预防
l=[1,2,3]
x=100
if x<len(l)
l[x]
2.2如果无法预知错误发生的条件，即错误一定会发生，应该使用try...except进行补救
2.为何要处理异常
增强程序的健壮性
3.如何处理异常
try:
被检测的代码1
被检测的代码2
被检测的代码3
except 异常类型1 as e:
print(e)
except 异常类型2 as e:
print(e)
except 异常类型3 as e:
print(e)
except Exception as e:
print(e)
.....................
else:#不能单独存在
print('当被检测的代码块没有发生异常时才会执行’)
finally:#可以单独存在
print('无论有无异常都会执行')#通常放回收资源的代码
'''
# try:
# xxx=1
# except Exception:
# print('万能异常')
# else:
# print('没有异常')
#
# try:
# f=open('a.txt')
# xxx
# except Exception:
# pass
# finally:
# print('无论有无异常都会执行')
# f.close()
# raise NameError('名字没有定义')
class People:
def __init__(self,name,age):
self.__name=name
self.__age=age
def tell_info(self):
print('%s:%s' %(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
raise TypeError('用户名必须传入str类型')
if not isinstance(age,int):
raise TypeError('年龄必须传入int类型')
self.__name=name
self.__age=age
obj=People('frank',18)
obj.tell_info()
obj.set_info('FRANK',19)
obj.tell_info()
obj.set_info(123,15)
# class MyException(BaseException):
# def __init__(self,msg):
# super().__init__()
# self.msg=msg
#
# def __str__(self):
# return '<<%s>>' %self.msg
# raise MyException('我自定义的异常')
# try:
# xxx=1
# dic={'a',1}
# dic['b']
# except:
# print('在抛出异常之前先回收资源')
# raise
# try:
# xxx=1
# finally:
# print('在抛出异常之前先回收资源')
五、进程介绍
1.什么是进程
进程就是一个正在进行/运行的程序，换言之，进程指的是一个程序的运行过程
程序VS进程
程序：只是一堆代码文件
进程：程序运行的过程才是进程
串行：一个任务完完整整的运行完毕，再执行下一个任务，安次序依次进行
串行看起来是一个一个运行：对
一个一个的运行就是串行：错误
并发（切换+保存状态）：多个任务看起来是同时运行，单核就可以实行并发
并行：多个任务是真正意义上的同事运行，只有多核才能实现并行
多道技术的产生背景：就想要在单核下实现并发
如何实现：
1.空间上的复用：将内存分为几部分，每个部分放入一个程序的数据，这样，同一时间内存中就有了多道程序的数据
为cpu在多个任务间切换做准备
2.时间上的复用：多个进程共享cpu的时间
关键点就是cpu在多个任务之间进行切换
1.一个任务占用cpu时间长（没有遇到IO操作）：会降低效率
2.一个任务在运行的过程中遇到IO操作：可以提升效率
2、为何要用进程
要实现并发效果
3.如何开启进程
六、创建子进程的两种方式：
#开启子进程方式1：
from multiprocessing import Process
import time
def task(name):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
#在windows系统上开启子进程的操作必须放到该行代码下：
if __name__ == '__main__':
p=Process(target=task,args=('子进程',)) #Process(target=task,kwargs={'name':'子进程'})
p.start()#仅仅只是向操作系统发一个创造一个子进程的信号
print('主')
#开启子进程方式2：
from multiprocessing import Process
import time
class Myprocess(Process):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
print('%s is running' %self.name)
time.sleep(3)
print('%s is done' %self.name)
#在windows系统上开启子进程的操作必须放到该行代码下
if __name__ == '__main__':
p=Myprocess('子进程')
p.start()
p.join()
print('主')
七、join方法
例1：
from multiprocessing import Process
import time
def task(name):
print('%s is runnnig' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
p=Process(target=task,args=('子进程',))
p.start()
p.join()#让主进程等待子进程p执行完毕后在执行主进程的后续代码
print('主')
执行结果：
例2：
from multiprocessing import Process
import time
def task(name,n):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
p1=Process(target=task,args=('子进程1',1))
p2=Process(target=task,args=('子进程2',2))
p3=Process(target=task,args=('子进程3',3))
start=time.time()
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
stop=time.time()
print('主',(stop-start))
执行结果：
例3：
from multiprocessing import Process
import time
def task(name,n):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
start=time.time()
p_1=[]
for i in range(1,4):
p=Process(target=task,args=('子进程%s' %i,i))
p_1.append(p)
p.start()
for p in p_1:
p.join()
stop=time.time()
print('主',(stop-start))
执行结果：
八、进程之间内存隔离
from multiprocessing import Process
import time
n=100
def task():
global n
n=0
if __name__ == '__main__':
p=Process(target=task,)
p.start()
p.join()
print('主',n)
执行结果：
九、进程PID
列1：
from multiprocessing import Process,current_process
import time
def task():
print('%s is running' %current_process().pid)
time.sleep(3)
print('%s is done' %current_process().pid)
if __name__ == '__main__':
p=Process(target=task)
p.start()
print(p.pid)
print('主',current_process().pid)
执行结果：
列2：
from multiprocessing import Process,current_process
import time,os
def task():
print('子进程[%s] 父进程<%s>' %(os.getpid(),os.getppid()))
time.sleep(10)
if __name__ == '__main__':
p=Process(target=task)
p.start()
print('主',os.getpid(),os.getppid())
time.sleep(20)
执行结果：
十、进程对象其他相关的属性或方法
#1.p.name
from multiprocessing import Process
import time,os
def task():
print('%s is running' %os.getpid())
time.sleep(3)
if __name__ == '__main__':
p=Process(target=task,name='子进程1')
p.start()
print(p.name)
print('主')
time.sleep(5)
执行结果：
例2：
from multiprocessing import Process
import time,os
def task():
print('%s is running' %os.getppid())
time.sleep(10)
if __name__ == '__main__':
p=Process(target=task,name='子进程1')
p.start()
p.terminate()
time.sleep(0.1)
print(p.is_alive())
print('主')
执行结果：
