threading模块基本使用

刺骨的言语ヽ痛彻心扉 2022-04-23 02:52 183阅读 0赞

# 简介 #

在Python提供了多个模块支持多线程编程，包括thread，threading和Queue模块等，推荐使用threading

# threading模块对象 #

<table> 
 <thead> 
  <tr> 
   <th>对象</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread</td> 
   <td>表示一个执行线程的对象</td> 
  </tr> 
  <tr> 
   <td>Lock</td> 
   <td>锁原语对象</td> 
  </tr> 
  <tr> 
   <td>RLock</td> 
   <td>可重入锁对象，使单一线程可以（再次）获得已持有的锁（递归锁）</td> 
  </tr> 
  <tr> 
   <td>Condition</td> 
   <td>条件变量对象，使得一个线程等待另一个线程满足特定的“条件”，比如改变状态或某个数据值</td> 
  </tr> 
  <tr> 
   <td>Event</td> 
   <td>条件变量的通用版本，任意数量的线程等待某个事件的发生，在该事件发生后所有线程将被激活</td> 
  </tr> 
  <tr> 
   <td>Semaphore</td> 
   <td>为线程间共享的有限资源提供了一个“计数器”，如果没有可用资源时会被阻塞</td> 
  </tr> 
  <tr> 
   <td>BoundedSemaphore</td> 
   <td>与 Semaphore 相似，不过它不允许超过初始值</td> 
  </tr> 
  <tr> 
   <td>Timer</td> 
   <td>与 Thread 相似，不过它要在运行前等待一段时间</td> 
  </tr> 
  <tr> 
   <td>Barrier</td> 
   <td>创建一个障碍，必须达到指定数量的线程才可以继续</td> 
  </tr> 
 </tbody> 
</table>

# Thread类属性和方法 #

### Thread 对象数据属性 ###

<table> 
 <thead> 
  <tr> 
   <th>Thread 对象数据属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name</td> 
   <td>线程名</td> 
  </tr> 
  <tr> 
   <td>ident</td> 
   <td>线程的标识符</td> 
  </tr> 
  <tr> 
   <td>daemon</td> 
   <td>布尔标志，表示这个线程是否是守护线程</td> 
  </tr> 
 </tbody> 
</table>

### Thread 对象方法 ###

<table> 
 <thead> 
  <tr> 
   <th>Thread 对象方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>__init__(group=None, tatget=None,args=(), kwargs ={}, verbose=None, daemon=None)</td> 
   <td>实例化一个线程对象，需要有一个可调用的 target，以及其参数 args或 kwargs。还可以传递 name 或 group 参数，不过后者还未实现。此外 ， verbose 标 志 也 是 可 接 受 的。 而 daemon 的 值 将 会 设定thread.daemon 属性/标志</td> 
  </tr> 
  <tr> 
   <td>start()</td> 
   <td>开始执行该线程</td> 
  </tr> 
  <tr> 
   <td>run()</td> 
   <td>定义线程功能的方法（通常在子类中被应用开发者重写）</td> 
  </tr> 
  <tr> 
   <td>join (timeout=None)</td> 
   <td>直至启动的线程终止之前一直挂起；除非给出了 timeout（秒），否则会一直阻塞</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>返回线程名</td> 
  </tr> 
  <tr> 
   <td>setName (name)</td> 
   <td>设定线程名</td> 
  </tr> 
  <tr> 
   <td>isAlivel /is_alive ()</td> 
   <td>布尔标志，表示这个线程是否还存活</td> 
  </tr> 
  <tr> 
   <td>isDaemon()</td> 
   <td>如果是守护线程，则返回 True；否则，返回 False</td> 
  </tr> 
  <tr> 
   <td>setDaemon(daemonic)</td> 
   <td>把线程的守护标志设定为布尔值 daemonic（必须在线程 start()之前调用）</td> 
  </tr> 
 </tbody> 
</table>

示例1：创建Thread实例，传递函数

import threading
    import time
    
    def read():
        for x in range(3):
            print('在%s,正在读书' % time.ctime())
            time.sleep(1)
    
    def write():
        for x in range(3):
            print('在%s,正在写字' % time.ctime())
            time.sleep(1)
    
    def main():
    
        read_threads = []  # 用来存放执行read函数线程的列表
        write_threads = []  # 用来存放执行write函数线程的列表
    
        for i in range(1,2):  # 创建1个线程用于read()，并添加到read_threads列表
            t = threading.Thread(target=read) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
            read_threads.append(t)
    
        for i in range(1,2): # 创建1个线程执行write()，并添加到write_threads列表
            t = threading.Thread(target=write) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
            write_threads.append(t)
    
        for i in range(0,1):  # 启动存放在read_threads和write_threads列表中的线程
            read_threads[i].start()
            write_threads[i].start()
    
    if __name__ == '__main__':
        main()

运行结果  
![20190123151142814.png][]

示例2：为了让线程更好的封装，可以用threading模块下的Thread类，继承这个类，然后实现run方法，线程就回自动运行run方法中的代码

import threading
    import time
    
    class read_thread(threading.Thread):
        def run(self):
            for x in range(3):
                print('在%s,正在读书(当前线程：%s)' % (time.ctime(),threading.current_thread()))
                time.sleep(1)
    
    class write_thread(threading.Thread):
        def run(self):
            for x in range(3):
                print('在%s,正在写字(当前线程：%s)' % (time.ctime(),threading.current_thread()))
                time.sleep(1)
    
    def main():
    
        read_threads = []  # 用来存放执行read函数线程的列表
        write_threads = []  # 用来存放执行write函数线程的列表
    
        for i in range(1,2):  # 创建1个线程用于read()，并添加到read_threads列表
            t = read_thread()  # 创建实例存放
            read_threads.append(t)
    
        for i in range(1,2): # 创建1个线程执行write()，并添加到write_threads列表
            t = write_thread()
            write_threads.append(t)
    
        for i in range(0,1):  # 启动存放在read_threads和write_threads列表中的线程
            read_threads[i].start()
            write_threads[i].start()
    
    if __name__ == '__main__':
        main()

运行结果：  
![在这里插入图片描述][20190123152612134.png]

# Lock对象 #

多线程是在同一个进程下运行的，因此在进程中的全局变量所有线程都是共享的，这就造成一个问题，因为线程执行的顺序是无序的，有可能会造成数据错误，如下面的函数

import threading
    
    value = 0
    def add_value():
        global value
        for x in range(10000000):
            value += 1
        print('value:',value)
    
    def main():
        threads = []
        for i in range(0,2):
            t = threading.Thread(target=add_value)
            threads.append(t)
    
        for i in range(0,2):
            threads[i].start()
    
    if __name__ == '__main__':
        main()

这时候运行结果为  
![在这里插入图片描述][20190123153933114.png]  
这个结果显然是不对的，这就是因为全局变量是共享的，线程运行又是无序的，而且value+1的命令次数变多，就会2个线程可能同时执行+1这时候数据就很容易发生混乱。

接下来引入锁机制

### LOCK 对象方法 ###

锁有两种状态：锁定和未锁定。而且也只有两个函数;获取锁和释放锁，当多线程争夺锁的时候，允许第一个获得锁的线程进入临界区，并执行代码，所有之后叨叨的线程都被阻塞，当第一个线程执行结束，退出临界区，释放锁，此时，其他等待的线程可以获得锁进入临界区，不过要记住，被阻塞的线程是无序的。

<table> 
 <thead> 
  <tr> 
   <th>LOCK 对象方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acquire()</td> 
   <td>获取锁（阻塞或非阻塞）</td> 
  </tr> 
  <tr> 
   <td>release()</td> 
   <td>释放锁</td> 
  </tr> 
 </tbody> 
</table>

示例：

import threading
    
    value = 0
    lock = threading.Lock() # 创建锁示例
    
    def add_value():
        global value
        lock.acquire() # 获得锁
        for x in range(10000000):
            value += 1
        lock.release() # 释放锁
        print('value:',value)
    
    def main():
        threads = []
        for i in range(0,2):
            t = threading.Thread(target=add_value)
            threads.append(t)
    
        for i in range(0,2):
            threads[i].start()
    
    if __name__ == '__main__':
        main()

![在这里插入图片描述][20190123155204955.png]  
现在就运行正常了

# Condition对象 #

LOCK锁机制存在一个问题，上锁是一个很耗费CPU资源的行为，这时候就可以考虑使用Condition对象,`threading.Condition()`可以再没有数据的时候处于阻塞等待状态，一旦有合适的数据，还可以使用notify相关的函数来通知其他处于等待状态的线程，这样就可以不用做一些无用的上锁和解锁操作，可以提高程序的性能

<table> 
 <thead> 
  <tr> 
   <th>Condition对象方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acquire()</td> 
   <td>获取锁</td> 
  </tr> 
  <tr> 
   <td>release()</td> 
   <td>释放锁</td> 
  </tr> 
  <tr> 
   <td>wait()</td> 
   <td>将当前线程处于等待状态，并释放锁。可以被其他线程使用notify和notify_all函数唤醒，被唤醒后会继续等待上锁，上锁后继续执行下面代码</td> 
  </tr> 
  <tr> 
   <td>notify()</td> 
   <td>通知正在等待的某个线程，默认是第一个等待的线程</td> 
  </tr> 
  <tr> 
   <td>nofity_all()</td> 
   <td>通知所有正在等待的线程，notify和nofify_all不会释放锁，并且需要在release（）之前调用</td> 
  </tr> 
 </tbody> 
</table>

示例代码：

创建两个类，Producer用于赚钱，并且规定每个线程只需要工作10次即可，Consumer用于消费。

Consumer每次花钱的时候会看一下金库的总额够不够，如果不够就会调用`gCondition.wait()`将线程处于等待，当Producer赚钱了，就会调用`gCondition.notify_all()`，提醒真正等待的线程，当线程被唤醒之后会继续等待上锁，上锁后继续执行下面代码

import  time
    import  threading
    import random
    
    gMoney = 1000
    gCondition = threading.Condition()
    gTotalTimes = 10
    gTimes = 0
    
    
    class Producer(threading.Thread):
        def run(self):
            global gMoney
            global gTimes
            while True:
                money = random.randint(100,1000)
                gCondition.acquire()
                if gTimes >= gTotalTimes:
                    gCondition.release()
                    break
                gMoney += money
                print("%s生产者生产了%d元，总额%d元" % (threading.current_thread(), money, gMoney))
                gTimes +=1
                gCondition.notify_all()
                gCondition.release()
                time.sleep(0.5)
    
    class Consumer(threading.Thread):
        def run(self):
            global gMoney
            while True:
                price = random.randint(500,1000)
                gCondition.acquire()
                while gMoney < price:
                    if gTimes>= gTotalTimes:
                        gCondition.release()
                        return
                    print('%s消费者准备消费%d,剩余%d,不足！' % (threading.current_thread(), price, gMoney))
                    gCondition.wait()
                gMoney -= price
                print('%s消费者消费了%d元，剩余%d' % (threading.current_thread(),price,gMoney))
                gCondition.release()
                time.sleep(0.5)
    
    def main():
        for x in range(3):
            t = Consumer(name='消费者线程%d'%x)
            t.start()
        for x in range(5):
            t = Producer(name = '生产者线程%d'%x )
            t.start()
    
    if __name__ == '__main__':
        main()

参考链接：

*  [https://docs.python.org/3.6/library/threading.html][https_docs.python.org_3.6_library_threading.html]

[20190123151142814.png]: /images/20220323/72f2f208e13a4b35858a5ee6a52e219b.png
[20190123152612134.png]: /images/20220323/4cfe641105004969bffb02ed6705aa56.png
[20190123153933114.png]: /images/20220323/f2c3055814864aeca7079db7e08dfe70.png
[20190123155204955.png]: /images/20220323/fdc0b4c811da4cf08b15abee50aee9ac.png
[https_docs.python.org_3.6_library_threading.html]: https://docs.python.org/3.6/library/threading.html