西安电子科技大学：《并行计算》课程教学资源（课件讲稿）Python并发编程部分（Python并发程序设计）

《并行计算：Parallel Computing》 结构 编程 算法应用 S3.4 Python:并发程序设计 徐悦牲Yueshen Xu)) ysxu@xidian.edu.cn 软件工程系 西安电子科技大学

§3.4 Python并发程序设计 徐悦甡(Yueshen Xu) ysxu@xidian.edu.cn 软件工程系 西安电子科技大学 《并行计算：Parallel Computing》 结构 编程 算法 应用

本节提纲 历忠毛子代栈大” XIDIAN UNIVERSITY ▣Pythoni语言基础 ▣Python基础语法 Pythoni语言 ▣Python面向对象编程 口Python并发程序设计(Concurrency)? ■Python多线程机制 Python并发编程 ■Pythont中线程的创建 关键字： Python 基础语法 变量与运算 并发编程 3

本节提纲 Python语言基础 Python基础语法 Python面向对象编程 Python并发程序设计（Concurrency） ◼ Python多线程机制 ◼ Python中线程的创建 Python语言 Python并发编程 关键字： Python 基础语法 变量与运算 并发编程 2

Python多线程编程 历安毛子代枚大 XIDIAN UNIVERSITY 口参考方法一：将要执行的函数作为参数传递给 threading.Thread() #!/usr/bin/env python3 for i in range(5): #-*-coding:utf-8-*- threads.append(threading.Thread(target import threading,time =func,args=(1000,))) def func(n): for t in threads: global count t.start() time.sleep(0.1) time.sleep(5) for i in range(n): print('count:',count) count +1 #main ends #def ends if name=='main': count =0 threads [

Python多线程编程  参考方法一：将要执行的函数作为参数传递给 threading.Thread() 3 #!/usr/bin/env python3 # -*- coding:utf-8 -*- import threading, time def func(n): global count time.sleep(0.1) for i in range(n): count += 1 #def ends if __name__==’__main__’: count = 0 threads = [] for i in range(5): threads.append(threading.Thread(target =func, args=(1000,))) for t in threads: t.start() time.sleep(5) print(‘count:’,count) #main ends

Python多线程编程 历些毛子种技大学 XIDIAN UNIVERSITY ■代码分析 threading.Thread(target=func,args=(1000,)) func为函数名，args为函数参数（必须以元组的形式传递）； >t.start(0:启动函数，等待操作系统调度； >函数运行结束，线程也就结束； >time.sleep(0:线程进入睡眠，处于HO阻塞状态 ■结果分析 >以上例子创建了5个线程去执行func函数 >获得的结果可能是5000，但也有时候会出现错误

Python多线程编程 ◼ 代码分析 ➢ threading.Thread(target=func, args=(1000,)) - func 为函数名，args 为函数参数（必须以元组的形式传递）； ➢ t.start(): 启动函数，等待操作系统调度； ➢ 函数运行结束，线程也就结束； ➢ time.sleep(): 线程进入睡眠，处于IO 阻塞状态 ◼ 结果分析 ➢ 以上例子创建了5 个线程去执行 func 函数 ➢ 获得的结果可能是 5000，但也有时候会出现错误 4

Python多线程编程 历忠荒子代枝大学 XIDIAN UNIVERSITY 口参考方法二：继承threading.Thread(0类，并重写run0( 推荐使用) #!/usr/bin/env python3 if name=='main': #-*-coding:utf-8 -* count 0 import threading,time threads =[ class myThread(threading.Thread): for i in range(5): def init (self,n): threads.append(myThread(1000)) threading.Thread._init(self) for t in threads: self.myThread_nn t.start() def run(self): time.sleep(5) global count print('count:',count) for i in range(self.myThread_n): count +1 #def ends

Python多线程编程  参考方法二：继承 threading.Thread()类，并重写run()（ 推荐使用） 5 #!/usr/bin/env python3 # -*- coding:utf-8 -*- import threading, time class myThread(threading.Thread): def __init__(self, n): threading.Thread.__init__(self) self.myThread_n = n def run(self): global count for i in range(self.myThread_n): count += 1 #def ends if __name__==’__main__’: count = 0 threads = [] for i in range(5): threads.append(myThread(1000)) for t in threads: t.start() time.sleep(5) print(‘count:’,count)

Python多线程编程 历安毛子代拔大” XIDIAN UNIVERSITY 口线程同步锁互斥控制 class myThread(threading.Thread): class myThread(threading.Thread): def init_(self,n): def init_(self,n): threading.Thread._init_(self) threading.Thread._init(self) self.myThread nn self.myThread nn def run(self): def run(self): global count global count for i in range(self.myThread_n): for i in range(self.myThread_n): count +1 _Temp count #def ends time.sleep(0.0001) count =__Temp +1 #def ends 6

Python多线程编程 线程同步锁互斥控制 6 class myThread(threading.Thread): def __init__(self, n): threading.Thread.__init__(self) self.myThread_n = n def run(self): global count for i in range(self.myThread_n): count += 1 #def ends class myThread(threading.Thread): def __init__(self, n): threading.Thread.__init__(self) self.myThread_n = n def run(self): global count for i in range(self.myThread_n): __Temp = count time.sleep(0.0001) count = __Temp + 1 #def ends

Python多线程编程 历些毛子代拔大》 XIDIAN UNIVERSITY 口线程同步锁互斥控制 import threading,time if name=='main_: class myThread(threading.Thread): count =0 def init (self,n): #同步锁，也称互斥量 threading.Thread.init (self) lock threading.Lock() self.myThread nn threads=[] def run(self): for i in range(5): global count threads.append(myThread(1000)) for i in range(self.myThread_n): for t in threads: if lock.acquire(): t.start() Temp count time.sleep(0.0001) time.sleep(5) count Temp +1 print('count:',count) lock.release()

Python多线程编程 线程同步锁互斥控制 7 import threading, time class myThread(threading.Thread): def __init__(self, n): threading.Thread.__init__(self) self.myThread_n = n def run(self): global count for i in range(self.myThread_n): if lock.acquire(): __Temp = count time.sleep(0.0001) count = __Temp + 1 lock.release() if __name__==’__main__’: count = 0 #同步锁，也称互斥量 lock = threading.Lock() threads = [] for i in range(5): threads.append(myThread(1000)) for t in threads: t.start() time.sleep(5) print(‘count:’,count)

Python多线程编程 历忠毛子代枚大” XIDIAN UNIVERSITY 口线程同步锁互斥控制 ■代码分析 >lock=threading.Lock0:创建锁； >b.lock.acquire([timeount]):请求锁定， ~如果设定了timeout,则在超时后通过返回值可以判断是否得到了锁， ·从而可以进行一些其他的处理： >c.lock.release0:释放锁定

Python多线程编程 线程同步锁互斥控制 ◼ 代码分析 ➢ lock = threading.Lock()：创建锁； ➢ b. lock.acquire([timeount])：请求锁定， - 如果设定了timeout，则在超时后通过返回值可以判断是否得到了锁， - 从而可以进行一些其他的处理； ➢ c. lock.release()：释放锁定 8

Python多线程编程 历些毛子代拔大学 XIDIAN UNIVERSITY 口threading:信号量 ■信号量用来控制线程并发数的 >BoundedSemaphore或Semaphore管理一个内置的计数器 。每当调用acquire0时-1， 调用release0时+1 >计数器不能小于0，当计数器为0时，acquire(0将阻塞线程至同 步锁定状态，直到其他线程调用release(0 >BoundedSemaphore与Semaphore的唯一区别在于 ~前者将在调用release0时检查计数器的值是否超过了计数器的初始值 如果超过将抛出一个异常

Python多线程编程  threading：信号量 ◼ 信号量用来控制线程并发数的 ➢ BoundedSemaphore 或Semaphore 管理一个内置的计数器 - 每当调用acquire()时-1， - 调用release() 时+1 ➢ 计数器不能小于0，当计数器为0 时，acquire()将阻塞线程至同 步锁定状态，直到其他线程调用release() ➢ BoundedSemaphore 与Semaphore 的唯一区别在于 - 前者将在调用release()时检查计数器的值是否超过了计数器的初始值 - 如果超过将抛出一个异常 9

Python多线程编程 历些毛子代牧大兽 XIDIAN UNIVERSITY ▣threading:信号量 #!/usr/bin/env python3 if name=='main': #-*-coding:utf-8-*- semaphore import threading,time threading.Semaphore(5) class myThread(threading.Thread): threads=[] def run(self): for i in range(100): if semaphore.acquire(): threads.append(myThread()) #注意观察semaphore for t in threads: print(self.name) t.start() time.sleep(5) semaphore.release() 0

Python多线程编程 threading：信号量 10 #!/usr/bin/env python3 # -*- coding:utf-8 -*- import threading, time class myThread(threading.Thread): def run(self): if semaphore.acquire(): #注意观察semaphore print(self.name) time.sleep(5) semaphore.release() if __name__==’__main__’: semaphore = threading.Semaphore(5) threads = [] for i in range(100): threads.append(myThread()) for t in threads: t.start()