基于udp协议支持并发的套接字/并发相关的概念/开启进程的两种方式/进程对象的方法

一：基于udp协议支持并发的套接字

客户端：


from socket import *

client = socket(AF_INET,SOCK_DGRAM)

while True:
    msg = input(">>>: ").strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',9999))
    res,server_addr = client.recvfrom(1024)
    print(res.decode('utf-8'))

服务端：


import socketserver

class MyRequestHanlder(socketserver.BaseRequestHandler):
    def handle(self):
        data,server = self.request
        server.sendto(data.upper(),self.client_address)


server = socketserver.ThreadingUDPServer(('127.0.0.1',9999),MyRequestHanlder)
server.serve_forever()

二：并发相关的概念

进程：正在运行的一个程序，是一个动态的概念，可以说是操作系统的干活过程（也就是操作系统控制硬件来运行程序的过程）

程序：就是一系列的代码文件，是一个静态的概念

多道技术：

（1）空间上的复用

（2）时间上的复用：CPU一天的使用时间分布在各个程序上，CPU在多个任务之间的快速切换：遇到io切，占用时间过长

并发：一台CPU上的来回切换

并行：真正意义上的并发

串行：一个运行完运行完下一个

一个任务的运行的三种状态：

1. 进程挂起是自身原因，遇到I/O阻塞，便要让出CPU让其他进程去执行，这样保证CPU一直在工作

2. 与进程无关，是操作系统层面，可能会因为一个进程占用时间过多，或者优先级等原因，而调用其他的进程去使用CPU。

　　因而一个进程由三种状态

提交任务的两种方式：

同步：提交完一个任务等待结果，再做另外一个任务；例如：叫一个外卖，等着她送达

异步：提交一个任务，不需要等待完成，就可以做下一个任务；例如：叫一个外卖，然后接下来我就做其他的事情

三：开启进程的两种方式

方法1：

from multiprocessing import Process #开启进程的命令
import os,time

def task(n):
    print('父进程：%s 自己：%s 正在运行' %(os.getppid(),os.getpid()))
    time.sleep(3)
    print('父进程：%s 自己：%s 运行完毕' %(os.getppid(),os.getpid()))

if __name__=='__main__':        #起进程的代码规定

　　p=Process(target=task,args=(3,)) 
　　p.start() #通知操作系统开启进程 
　　print('主',os.getpid())

结果：

主 16072
父进程 16072 自己的12424 正在运行
父进程 16072 自己的12424 运行结束

方法2：

from multiprocessing import Process
import os,time

class Myprocess(Process):
    def __init__(self,n):
        super().__init__()
        self.n=n

    def run(self) -> None:
        print('父进程 %s 自己的%s 正在运行' %(os.getppid(),os.getpid()))
        time.sleep(2)
        print('父进程 %s 自己的%s 运行结束' %(os.getppid(),os.getpid()))

if __name__=='__main__':
    p=Myprocess(3)
    p.start()
    print('主',os.getpid())

四：进程内存空间之间彼此隔离

import time,os
from multiprocessing import Process

count=100

def task():
    global count
    count=0
if __name__=='__main__':
    p=Process(target=task)
    p.start()
    time.sleep(3)
    print('主',count)

结果是：主 100

五：进程对象的方法

1. .join的作用是等待进程结束结束的最佳等待时间，下方的例子就是p.join()是等子进程刚运行结束就运行主进程去替代上个例子中的 time.sleep（5）

import os,time
from multiprocessing import Process

count=100
def task():
    global count
    count=0

if __name__=='__main__':
    p=Process(target=task)
    p.start()
    p.join()
    print('主',count)

2.join的另一个例子

from multiprocessing import  Process
import os,time

def task(n):
    print(os.getppid())
    time.sleep(n)

if __name__=='__main__':
    p1=Process(target=task,args=(3,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(1,))

    start=time.time()
    p1.start()
    p2.start()
    p3.start()

    p3.join()
    p2.join()
    p1.join()

    stop=time.time()
    print(stop-start)

结果是：

6924
6924
6924
3.1128039360046387

3.join的其他用法from multiprocessing import Process

import os,time

def task(n):
    print(os.getppid())
    time.sleep(n)

if __name__=='__main__':
    p1=Process(target=task,args=(3,)) 可以在造进程对象的时候给进程命名：p1=Process(target=task,args=(3,)，name=‘hjklgh’)

p2=Process(target=task,args=(2,)) p3=Process(target=task,args=(1,)) start=time.time() p1.start() p2.start() p3.start() p1.join() p2.join() p3.join() stop=time.time() print(stop-start) 
　　p1.name    #看一个进程的名字
　　p1.pid     #看进程的ID
p1.is_alive   #判断进程是否存活的

p1.terminate()#结束p1这个进程