一、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))
