UDC协议,并发程序 和进程

Posted bs2019

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了UDC协议,并发程序 和进程相关的知识,希望对你有一定的参考价值。

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的子进程
主进程...
主进程...
主进程...
主进程...
主进程...

?

?

?

以上是关于UDC协议,并发程序 和进程的主要内容,如果未能解决你的问题,请参考以下文章

多个请求是多线程吗

Python:并发编程

网络协议的比较

进程对象的其他方法守护进程使用多进程实现 socket tcp协议 server端的并发(抢票程序)队列进程之间的通信(IPC)

使用多进程 实现socket tcp协议 server端的并发

多线程