udp协议，进程（同步，异步）

udp协议与进程

一、udp协议

• QQ聊天室

#- 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的利用率极低
            - 单用户（一份代码使用）

![](https://img2018.cnblogs.com/blog/1843751/201912/1843751-20191206195817239-1051109546.png)

        - 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的执行权限剥夺

                    缺点：
                        - 程序的执行效率低
![](https://img2018.cnblogs.com/blog/1843751/201912/1843751-20191206195843026-150840510.png)

        - 并发与并行；（*******）
            - 并发（一个人）：
                在单核（一个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

![](https://img2018.cnblogs.com/blog/1843751/201912/1843751-20191206195906574-1537643301.png)

   面试题：阻塞与同步是一样的吗？非阻塞与异步是一样的吗？
    - 同步与异步：提交任务的方式

    - 阻塞非阻塞：进程的状态

    - 异步与非阻塞：--->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的子进程
主进程

• 方式二继承process

#方式二：
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的子进程
# 主进程...