并发编程

标签：send   支持   非阻塞   运行   bin   app   作业   正在执行   算法   

udp协议：

所谓udp协议就是用户数据报协议，是一个简单的面向数据报的运输层协议。只是将应用程序的数据报发送出去，但是并不保证是否发送到目的地。

客户端：
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
#连接到的服务端的地址
addres = (‘127.0.0.1‘,9000)
while True:
    msg = input(‘:‘).encode(‘utf-8‘)
    client.sendto(msg,addres)
    #接收消息时要接受数据的同时加上发送端的地址
    data,addr = client.recvfrom(1024)
    print(data)
    
    
服务端：
import socket
#socket.SOCK_DGRAM--->UDP协议
server = socket.socket(type=socket.SOCK_DGRAM)
#绑定一个地址让客户端链接到本机
server.bind((‘127.0.0.1‘,9000))
while True:
    #接受数据时加上服务端的用户地址
    data,addr = server.recvfrom(1024)
    print(addr)
    print(data)
    abc = input(‘:‘).encode(‘utf-8‘)
    #无论服务端还是客户端，发送消息时，都必须知道对方是谁
    server.sendto(abc, addr)

特点： 优点：

不需要建立连接传输速度快

不需要知道对方是否收到能支持并发

数据不安全不会粘包

传输速度快缺点：

能支持并发数据不安全，容易丢失

不会粘包

并发编程:

1.操作系统发展史：

1.穿孔卡片

读取数据速度特别慢，cpu利用率极低，单用户使用

2.批量处理：

联机使用，效率不是很低。

3.脱机批处理：

读取速度提高，cpu利用率提高。

2.多道技术：（基于单核背景下产生的）

单道：

a，b同时使用cpu，a先使用，b等a使用完毕后才能使用。

多道：

a,b同时使用cpu，a先使用，b等待a进入I/O模式或执行时间过长，a（切换+保存状态）然后给b使用cpu，待执行遇到i/o或执行时间过长，再将cpu权限，交给a知道两个程序结束。

空间上的复用：

多个程序使用一个cpu

时间上的服用：

切换+保存状态

1）当执行程序遇到IO时，操作系统会将cpu的使用权限剥夺。

优点：cpu的执行效率提高

2）当执行程序执行时间过长时，操作系统会将cpu的执行权限剥夺

缺点：程序的执行效率低

3.并发与并行

并发（单核模式）：当执行两个程序时，他们，看起来像同时运行

并行（多核模式）:当执行两个两个程序时，他们时真正意义上的同时运行。

4.进程

进程与程序：

进程：执行代码的过程，称之为进程

程序：一堆代码的集合体

进程调度：

1）先来先服务，调度算法

多个程序，谁先来，谁先服务，一个服务完毕后，另一个再服务，--执行效率低。

2）短作业优先调度算法

执行时间越短，则先调度。 --导致执行的时间长的程序，需要等待时间短的执行完毕之后才能执行。

3）时间片轮转法：

根据进程的数量将时间划分成进程数等分的时间，按照短作业优先调度法执行。

4）多级反馈队列：

按照优先级执行队列中的程序

5.同步与异步：都是提交任务的方式

同步：多个程序按照执行顺序的先后顺序提交任务

异步：多个程序无需按照执行顺序的先后提交任务

6.阻塞与非阻塞

阻塞：凡是遇到I/O的都会阻塞（等待）

i/o：input() output() time.sleep() 文件的读写 数据的传输

非阻塞：除了I/o的都是非阻塞（不等待）

7.进程的三种状态：

就绪态：同步与异步

运行态：程序的执行时间过长-----将程序返回给就绪态

阻塞态：遇到I/O

进程的两种创建方式：
import time
def task(name):
    print(f‘start...{name}的子进程‘)
    time.sleep(3)
    print(f‘end...{name}的子进程‘)
if __name__ == ‘__main__‘:
    # obj = Process(target=task, args=(‘啥意思啊‘,))
    # obj2 = Process(target=task, args=(‘看不懂啊‘,))
    # obj.start()
    # obj2.start()
    # obj.join()
    # obj2.join()
    #
    # print(‘正在执行当前主进程‘)
    list1 = []
    for line in range(5):
        obj3 = Process(target=task,args=(‘真看不懂啊‘,))
        obj3.start()
        list1.append(obj3)
    for jjj in list1:
        jjj.join()
    print(‘主进程‘)
    
from multiprocessing import Process
import time
class Myprocess(Process):
    def run(self):
        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(‘主进程分不清啊‘)

并发编程

标签：send   支持   非阻塞   运行   bin   app   作业   正在执行   算法   

原文地址：https://www.cnblogs.com/cyfdtz/p/12000526.html