UDC协议，并发程序 和进程

Posted 2020-11-24 bs2019

目录

• 1.UDP协议
  • 2.并发编程

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

?

?

?