网站前置或专项审批,建设返利网站,wordpress修订版本删除,怎么制作网站?一、多线程
二、多线程编程之threading模块
2.1、使用threading进行多线程操作有两种方法#xff1a;
三、多线程同步之Lock#xff08;互斥锁#xff09;
四、多线程同步之Semaphore#xff08;信号量#xff09;
五、多线程同步之Condition
六、多线程同步之Event…
一、多线程
二、多线程编程之threading模块
2.1、使用threading进行多线程操作有两种方法
三、多线程同步之Lock互斥锁
四、多线程同步之Semaphore信号量
五、多线程同步之Condition
六、多线程同步之Event
七、线程优先级队列queue
八、多线程之线程池pool
九、总结 一、多线程
线程Thread也称轻量级进程是操作系统能够运行调度的最小单位被包含在进程中是进程中的实际运作单位。
线程自身不拥有系统资源只拥有一些在运行中必不可少的资源但可与同属一个进程的其他线程共享所拥有的全部资源
一个线程可以创建和撤销另一个线程同一进程中的多个线程之间可以并发执行
就绪状态指线程具备运行的所有状态逻辑上可以运行在等待处理机运行状态指线程占有处理机正在运行 阻塞状态指线程在等待一个事件逻辑上不可执行
尽管GIL全局锁 限制了CPython多线程在CPU密集型任务中的并行性但Python的多线程在I/O密集型任务中依然能够发挥多核CPU的优势通过在I/O等待期间执行其他任务来提升程序的运行效率。
实例1计算密集型任务-多进程多进程多进程 from multiprocessing import Processimport os,time# 计算密集型任务def work():res 0for i in range(100000000):res * iif __name__ __main__:l []print(本机为,os.cpu_count(),核 CPU)start time.time()for i in range(4):p Process(targetwork) # 多进程l.append(p)p.start()for p in l:p.join()stop time.time()print(计算密集型任务多进程耗时 %s % (stop - start))本机为 8 核 CPU计算密集型任务多进程耗时 5.117187976837158
实例1计算密集型任务-多线程多线程多线程 import os,timefrom threading import Thread# 计算密集型任务def work():res 0for i in range(100000000):res * iif __name__ __main__:l []print(本机为,os.cpu_count(),核 CPU)start time.time()for i in range(4):p Thread(targetwork) # 多线程l.append(p)p.start()for p in l:p.join()stop time.time()print(计算密集型任务多线程耗时 %s % (stop - start))本机为 8 核 CPU计算密集型任务多线程耗时 14.287675857543945
实例2I/O密集型任务-多进程多进程多进程 from multiprocessing import Processimport os,time# I/O密集型任务def work():time.sleep(2)print(,fileopen(tmp.txt,w))if __name__ __main__:l []print(本机为, os.cpu_count(), 核 CPU)start time.time()for i in range(400):p Process(targetwork) # 多进程l.append(p)p.start()for p in l:p.join()stop time.time()print(I/O密集型任务多进程耗时 %s % (stop - start))本机为 8 核 CPUI/O密集型任务多进程耗时 11.03010869026184
实例2I/O密集型任务-多线程多线程多线程 import os,timefrom threading import Thread# I/O密集型任务def work():time.sleep(2)print(,fileopen(tmp.txt,w))if __name__ __main__:l []print(本机为, os.cpu_count(), 核 CPU)start time.time()for i in range(400):p Thread(targetwork) # 多线程l.append(p)p.start()for p in l:p.join()stop time.time()print(I/O密集型任务多线程耗时 %s % (stop - start))本机为 8 核 CPUI/O密集型任务多线程耗时 2.0814177989959717
结论在Python中对于密集型任务多进程占优势对于I/O密集型任务多线程占优势。
二、多线程编程之threading模块
Python提供多线程编程的模块有两个thread和threading。thread模块提供低级别的基本功能来支持提供简单的锁来确保同步不推荐。threading模块对_thread进行了封装提供了更高级别功能更强。
2.1、使用threading进行多线程操作有两种方法
方法一创建threading.Thread类的实例调用其start()方法 import timeimport threadingdef task_thread(counter):print(f线程名称{threading.current_thread().name} 参数{counter} 开始时间{time.strftime(%Y-%m-%d %H:%M:%S)})num counterwhile num:time.sleep(3)num - 1print(f线程名称{threading.current_thread().name} 参数{counter} 结束时间{time.strftime(%Y-%m-%d %H:%M:%S)})if __name__ __main__:print(f主线程开始时间:{time.strftime(%Y-%m-%d %H:%M:%S)})# 初始化三个线程传递不同的参数t1 threading.Thread(targettask_thread,args(3,))t2 threading.Thread(targettask_thread,args(2,))t3 threading.Thread(targettask_thread,args(1,))# 开启三个线程t1.start();t2.start();t3.start()# 等待运行结束t1.join();t2.join();t3.join()print(f主线程结束时间:{time.strftime(%Y-%m-%d %H:%M:%S)})程序实例化了三个Thread类的实例并任务函数传递不同的参数使他们运行不同的时间后结束start()方法开启线程join()方法阻塞主线程等待当前线程运行结束。
方法二继承Thread类在子类中重写run()和init()方法*了解--- import timeimport threadingclass MyThread(threading.Thread):def __init__(self,counter):super().__init__()self.counter counterdef run(self):print(f线程名称{threading.current_thread().name} 参数{self.counter} 开始时间{time.strftime(%Y-%m-%d %H:%M:%S)})counter self.counterwhile counter:time.sleep(3)counter - 1print(f线程名称{threading.current_thread().name} 参数{self.counter} 结束时间{time.strftime(%Y-%m-%d %H:%M:%S)})if __name__ __main__:print(f主线程开始时间:{time.strftime(%Y-%m-%d %H:%M:%S)})# 初始化三个线程传递不同的参数t1 MyThread(3)t2 MyThread(2)t3 MyThread(1)# 开启三个线程t1.start();t2.start();t3.start()# 等待运行结束t1.join();t2.join();t3.join()print(f主线程结束时间:{time.strftime(%Y-%m-%d %H:%M:%S)})
如果继承Thread类想要调用外部函数 import timeimport threadingdef task_thread(counter):print(f线程名称{threading.current_thread().name} 参数{counter} 开始时间{time.strftime(%Y-%m-%d %H:%M:%S)})num counterwhile num:time.sleep(3)num - 1print(f线程名称{threading.current_thread().name} 参数{counter} 结束时间{time.strftime(%Y-%m-%d %H:%M:%S)})class MyThread(threading.Thread):def __init__(self,target,args):super().__init__()self.args argsself.target targetdef run(self):self.target(*self.args)if __name__ __main__:print(f主线程开始时间:{time.strftime(%Y-%m-%d %H:%M:%S)})# 初始化三个线程传递不同的参数t1 MyThread(targettask_thread,args(3,))t2 MyThread(targettask_thread,args(2,))t3 MyThread(targettask_thread,args(1,))# 开启三个线程t1.start();t2.start();t3.start()# 等待运行结束t1.join();t2.join();t3.join()print(f主线程结束时间:{time.strftime(%Y-%m-%d %H:%M:%S)})
三、多线程同步之Lock互斥锁
如果多个线程共同对某个数据修改则可能出现不可预料的结果这个时候就需要使用互斥锁来进行同步。例如在三个线程对共同变量num进行100万次加减操作后其num的结果不为0
不加锁的意外情况 import time,threadingnum 0def task_thread(n):global numfor i in range(1000000):num num nnum num - nt1 threading.Thread(targettask_thread,args(6,))t2 threading.Thread(targettask_thread,args(17,))t3 threading.Thread(targettask_thread,args(11,))t1.start();t2.start();t3.start()t1.join();t2.join();t3.join()print(num)6
使用互斥锁对多个线程进行同步限制当一个线程正在访问数据时其他只能等待直到前一线程释放锁。
使用threading.Thread对象的Lock和Rlock可以实现简单的线程同步都有acquire和release方法。 # 加互斥锁后运行结果始终一致import time,threadingnum 0lock threading.Lock()def task_thread(n):global num# 获取锁用于线程同步lock.acquire()for i in range(1000000):num num nnum num - n# 释放锁开启下一个线程lock.release()t1 threading.Thread(targettask_thread,args(6,))t2 threading.Thread(targettask_thread,args(17,))t3 threading.Thread(targettask_thread,args(11,))t1.start();t2.start();t3.start()t1.join();t2.join();t3.join()print(num)
四、多线程同步之Semaphore信号量
互斥锁是只允许一个线程访问共享数据而信号量是同时运行一定数量的线程访问共享数据比如银行柜台有5个窗口运行同时有5个人办理业务后面的人只能等待其完成。 # 使用信号量控制并发import threadingimport time# 银行柜台窗口数量NUM_WINDOWS 5# 用于控制窗口访问的信号量semaphore threading.Semaphore(NUM_WINDOWS)# 客户办理业务的函数def customer(name, service_time):# 尝试获取信号量semaphore.acquire()print(f{time.ctime()}: {name} 开始办理业务)time.sleep(service_time) # 模拟办理业务的时间print(f{time.ctime()}: {name} 办理业务完成)semaphore.release() # 释放信号量# 创建客户线程列表customers []for i in range(12):name f客户{i1}service_time 3 # 假设每个客户办理业务需要1秒时间thread threading.Thread(targetcustomer, args(name, service_time))customers.append(thread)# 启动所有客户线程for customer in customers:customer.start()# 等待所有客户完成业务for customer in customers:customer.join()print(所有客户都办理完业务了。)
上述代码实现了同一时刻只有5个线程获得资源运行
五、多线程同步之Condition
条件对象Condition能让一个线程A停下来等待其他线程B线程B满足了某个条件后通知线程A继续运行。步骤
线程首先获取一个条件变量锁如果条件不足则该线程等待wait并释放条件变量锁如果条件满足就继续执行线程执行完成后可以通知notify其他状态为wait的线程执行。其他处于wait状态的线程接到通知后会重新判断条件来确定是否继续执行 import threadingclass Boy(threading.Thread):def __init__(self,cond,name):super(Boy,self).__init__()self.cond condself.name namedef run(self):self.cond.acquire()print(self.name :嫁给我吧)self.cond.notify() # 唤醒一个挂起的线程让hanmeimei表态self.cond.wait() # 释放内部所占用的锁同时线程被挂起直至接收到通知被唤醒或超时等待heimeimei回答print(self.name : 我单膝下跪送上戒指)self.cond.notify()self.cond.wait()print(self.name : lI太太你的选择太明智了。)self.cond.release()class Girl(threading.Thread):def __init__(self,cond,name):super(Girl,self).__init__()self.cond condself.name namedef run(self):self.cond.acquire()self.cond.wait() # 等待Lilei求婚print(self.name : 没有情调不够浪漫不答应)self.cond.notify()self.cond.wait()print(self.name : 好吧答应你了)self.cond.notify()self.cond.release()cond threading.Condition()boy Boy(cond,LiLei)girl Girl(cond,HanMeiMei)girl.start()boy.start()
六、多线程同步之Event
事件用于线程之间的通信。一个线程发出一个信号其他一个或多个线程等待调用Event对象的wait方法线程则会阻塞等待直到别的线程set之后才会被唤醒。与上述类似 import threadingimport timeclass Boy(threading.Thread):def __init__(self,cond,name):super(Boy,self).__init__()self.cond condself.name namedef run(self):print(self.name :嫁给我吧)self.cond.set() # 唤醒一个挂起的线程让hanmeimei表态time.sleep(0.5)self.cond.wait() # 释放内部所占用的锁同时线程被挂起直至接收到通知被唤醒或超时等待heimeimei回答print(self.name : 我单膝下跪送上戒指)self.cond.set()time.sleep(0.5)self.cond.wait()self.cond.clear()print(self.name : lI太太你的选择太明智了。)class Girl(threading.Thread):def __init__(self,cond,name):super(Girl,self).__init__()self.cond condself.name namedef run(self):self.cond.wait() # 等待Lilei求婚self.cond.clear()print(self.name : 没有情调不够浪漫不答应)self.cond.set()time.sleep(0.5)self.cond.wait()print(self.name : 好吧答应你了)self.cond.set()cond threading.Event()boy Boy(cond,LiLei)girl Girl(cond,HanMeiMei)girl.start()boy.start()
七、线程优先级队列queue
Python的queue模块中提供了同步的、线程安全的队列类包括先进先出队列Queue、后进先出队列LifoQueue和优先级队列PriorityQueue。这些队列都实现了锁原语可以直接使用来实现线程之间的同步。 有一小冰箱用来存放冷饮假如只能放5瓶冷饮A不停地放冷饮B不停的取冷饮A和B的放取速度不一致如何保持同步呢import threading,timeimport queue# 先进先出q queue.Queue(maxsize5)# q LifoQuere(maxsize3)# q PriorityQueue(maxsize3)def ProducerA():count 1while True:q.put(f冷饮 {count})print(f{time.strftime(%H:%M:%S)} A 放入[冷饮 {count}])count 1time.sleep(2)def ConsumerB():while True:print(f{time.strftime(%H:%M:%S)} B 取出{q.get()})time.sleep(5)p threading.Thread(targetProducerA)c threading.Thread(targetConsumerB)p.start()c.start()
八、多线程之线程池pool
将 任务添加到线程池中线程池会自动指定一个空闲的线程去执行任务当超过线程池的最大线程数时任务需要等待有新的空闲线程后才会被执行。
使用threading模块及queue模块定制线程池可以使用multiprocessing。 from multiprocessing import Pool导入的是进程池 from multiprocessing.dummy import Pool导入的是线程池 模拟一个耗时2秒的任务比较其顺序执行5次和线程池并发数为5执行的耗时。from multiprocessing.dummy import Pool as ThreadPoolimport timedef fun(n):time.sleep(2)start time.time()for i in range(5):fun(i)print(单线程顺序执行耗时,time.time() - start)start2 time.time()# 开8个worker没有参数时默认是cpu的核心数pool ThreadPool(processes5)# 在线程中执行urllib2.urlopen(url)并返回执行结果results2 pool.map(fun,range(5))pool.close()pool.join()print(线程池5并发执行耗时,time.time() - start2)单线程顺序执行耗时 10.041245937347412线程池5并发执行耗时 2.0453202724456787
九、总结
Python多线程适合用在I/O密集型任务中。对于I/O密集型任务来说较少时间用在CPU计算上较多时间用在I/O上如文件读写、web请求、数据库请求等 对于计算密集型任务应该使用多进程
