Python学习笔记九（UDP套接字和并发编程）

一、UDP套接字

服务端

from socket import *
server = socket(AF_INET,SOCK_DGRAM)
server.bind(("127.0.0.1",8080))
while True:
    data,client_addr = server.recvfrom(1024)
    server.sendto(data.upper(),client_addr)

客户端

from socket import *
client = socket(AF_INET,SOCK_DGRAM)
while True:
    msg = input(">>").strip()
    client.sendto(msg.encode("utf-8"),("127.0.0.1",8080))
    data,server_addr = client.recvfrom(1024)
    print(data.decode("utf-8"))

二、进程相关定义

进程是指程序的运行过程。每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。

多道技术：内存中同时存入多个程序，cpu从一个进程快速切换到另一个，使得每个进程各自运行几十或几百毫秒，虽然在一个时刻，一个cpu只执行了一个任务，但1秒内，cpu却可以运行多个进程，给人带来并行的错觉，即伪并发，以此来区分多处理器操作系统的真正硬件并行（多cpu共享一个内存）

进程三种状态间的转换：

三、python多进程编程

为了利用多核CPU资源，python中使用multiprocessing多线程模块，python多线程无法利用多核优势。进程之间无任何共享数据，进程修改数据仅限进程内。

Process类常用方法：
p.start()   启动进程，调用紫禁城的p.run()方法
p.run()    进程启动时运行的方法，调用target制定的函数，自定义类中必须实现该方法。
p.terminate()  强调终止进程p，不会进行任何清理操作，如果p创建了子进程，该进程就成为了僵尸进程。如果p还保存了一个锁，那么锁也不会释放，导致死锁。
p.is_alive()  如果p仍然运行，返回True
p.join([timeout]) 主线程等待p进程终止。timeout为可选超时时间。

Process类常用属性
p.daemon 默认为False，设置为True后，p代表后台运行的守护进程，当p的父进程终止时，p也随之终止。设定为True后，p不能创建子进程，且必须在p.start()前设置。
p.name 进程名
p.pid    进程pid
p.exitcode  进程在运行时为None，如果为-N，表示被信号N结束
p.authkey  进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功

创建子进程的两种方式

from multiprocessing import Process
import time
def task(name):
    print("%s is running"%name)
    time.sleep(3)
    print("%s is done"%name)
if __name__=="__main__":
    p = Process(target=task,args=("aaa",))
    p.start()
    print("main")

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess,self).__init__()
        self.name = name
    def run(self):
        print("%s is running"%self.name)
        time.sleep(3)
        print("%s is done"%self.name)
if __name__=="__main__":
    p=MyProcess("进程1")
    p.start()
    print("main")

使用join方法等待子进程结束

from multiprocessing import Process
import time
def task(name):
    print("%s is running"%name)
    time.sleep(3)
    print("%s is done"%name)
if __name__=="__main__":
    p = Process(target=task,args=("aaa",))
    p.start()
    p.join()
    print("main")

守护进程

from multiprocessing import Process
import time
def task(name):
    # p = Process(target=time.sleep,args=(1,))  #守护进程无法创建子进程，会报错。
    # p.start()
    print("%s is running"%name)
    time.sleep(3)
    print("%s is done"%name)
if __name__ == "__main__":
    p = Process(target=task,args=("xxx",))
    p.daemon=True
    p.start()
    time.sleep(1)
    print("main")   #主进程在此结束，守护进程也会结束。

from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")
def bar():
    print(456)
    time.sleep(3)
    print("end456")
if __name__=="__main__":
    p1=Process(target=foo)
    p2=Process(target=bar)
    p1.daemon=True
    p1.start()
    p2.start()
    print("main")   #主进程执行完后，p1守护进程还输入123就已经结束，不过在p2会执行完后，主进程才会结束

互斥锁，针对进程间需要共同操作的资源，需要添加互斥锁

#模拟抢票程序
from multiprocessing import Process,Lock
import json
import time
import random
import os
def search():
    time.sleep(random.randint(1,3))
    dic = json.load(open("db.txt",‘r‘,encoding="utf-8"))
    print("%s查看剩余票数为%s"%(os.getpid(),dic["count"]))
def get():
    dic=json.load(open("db.txt",‘r‘,encoding="utf-8"))
    if dic["count"]>0:
        dic["count"]-=1
        time.sleep(random.randint(1,3))
        json.dump(dic,open("db.txt",‘w‘,encoding="utf-8"))
        print("%s购票成功"%os.getpid())
def task(mutex):
    search()
    mutex.acquire()
    get()     #对操作余票的函数加锁
    mutex.release()
if __name__=="__main__":
    mutex = Lock()
    for i in range(10):
        p=Process(target=task,args=(mutex,)) #进程间数据不互通，需用参数传入锁
        p.start()

使用Queue实现生产者消费者模型，Queue自带锁。

from multiprocessing import Process,Queue
import time
import random

def producer(name,food,q):
    for i in range(10):
        res="%s%s"%(food,i)
        time.sleep(random.randint(1,3))
        q.put(res)
        print("厨师[%s]生产了[%s]"%(name,res))
def consumer(name,q):
    while True:
        res = q.get()
        time.sleep(random.randint(1,3))
        print("吃货[%s]吃了[%s]"%(name,res))
if __name__=="__main__":
    q=Queue()
    p1 = Process(target=producer,args=("厨师1","包子",q))
    c1 = Process(target=consumer,args=("猪1",q))
    p1.start()
    c1.start()
    print("main")

上面的程序中生产者做完产品后，消费者并不知道已经生产完了，仍在在等着消费，主进程阻塞无法结束。

通过使用JoinableQueue队列可解决以上问题。

from multiprocessing import Process,JoinableQueue
import time
import random

def producer(name,food,q):
    for i in range(10):
        res="%s%s"%(food,i)
        time.sleep(random.randint(1,3))
        q.put(res)
        print("厨师[%s]生产了[%s]"%(name,res))
def consumer(name,q):
    while True:
        res = q.get()
        time.sleep(random.randint(1,3))
        print("吃货[%s]吃了[%s]"%(name,res))
        q.task_done()
if __name__=="__main__":
    q=JoinableQueue()
    p1 = Process(target=producer,args=("厨师1","包子",q))
    c1 = Process(target=consumer,args=("猪1",q))
    c1.daemon=True     #c1中有死循环，需要设置为守护进程，主进程结束自动结束消费者。
    p1.start()
    c1.start()
    p1.join()
    q.join()
    print("main")

四.线程介绍

1.线程相关定义

线程与进程类似，不过是在同一进程下执行的，并且共享一片数据空间。进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

使用多线程的原因：

a）多线程共享一个进程的地址空间

b）线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程快10-100倍，再有大量线程需要动态和快速修改时，较有用。

c）若多线程是cpu密集型，那么并不能获得性能上的增强，但如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而加快程序执行的速度。

2.创建线程

python中使用threading模块创建线程，和multiprocess模块类似。

#第一种方式
from threading import Thread
import time
import random

def task(name):
    print("%s is running"%name)
    time.sleep(random.randint(1,3))
    print("%s is done"%name)
if __name__=="__main__":
    t1 = Thread(target=task,args=("xxx",))
    t1.start()
    print("main")  #先输出线程中的内容

#第二种方式
from threading import Thread
import time
import random
class MyThread(Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.name = name
    def run(self):
        print("%s is running"%self.name)
        time.sleep(random.randint(1,3))
        print("%s is done"%self.name)
if __name__=="__main__":
    t1 = MyThread("xxx")
    t1.start()
    print("main")  #先输出线程中的内容

3.GIL

尽管python解释器中可以运行多个线程，但在任意给定时刻只有一个线程会被解释器执行。GIL本质为一个互斥锁，将并发运行变成串行。

对于任意面向I/O的Python功能，GIL会在I/O调用前被释放，以允许其他线程在I/O执行的时候运行。而对于没有太多I/O操作的代码，更倾向于在该线程整个时间片内始终占用处理器和GIL。

I/O密集型Python程序比计算密集型代码能够更好地利用多线程环境。

计算密集型程序，多进程效率高，主要用于金融分析。

from multiprocessing import Process
from threading import Thread
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i
if __name__=="__main__":
    l=[]
    print(os.cpu_count())   #8核
    start=time.time()
    for i in range(4):
        # p = Process(target=work)    #多进程为6.448570728302002秒
        p = Thread(target=work)   #多线程为21.265116930007935秒
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop = time.time()
    print("run time is %s"%(stop-start))

I/O密集型程序，多线程效率高，主要用于socket、爬虫、web等。

from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
    time.sleep(2)
    print("==>")
if __name__=="__main__":
    l=[]
    print(os.cpu_count())
    start=time.time()
    for i in range(400):
        # p = Process(target=work)  #多进程9.083257913589478秒
        p = Thread(target=work)     #多线程2.039461612701416秒
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop = time.time()
    print("run time is %s"%(stop-start))

原文地址：https://www.cnblogs.com/n1ghtwatcher/p/8414591.html