threading模块基本使用

简介

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

threading模块对象

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

Thread类属性和方法

Thread 对象数据属性

Thread 对象数据属性	描述
name	线程名
ident	线程的标识符
daemon	布尔标志，表示这个线程是否是守护线程

Thread 对象方法

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

示例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()

运行结果

示例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()

运行结果：

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()

这时候运行结果为

这个结果显然是不对的，这就是因为全局变量是共享的，线程运行又是无序的，而且value+1的命令次数变多，就会2个线程可能同时执行+1这时候数据就很容易发生混乱。

接下来引入锁机制

LOCK 对象方法

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

LOCK 对象方法	描述
acquire()	获取锁（阻塞或非阻塞）
release()	释放锁

示例：

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()

现在就运行正常了

Condition对象

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

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

示例代码：

创建两个类，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