python多线程模块（threading、queue、concurrent.futures）学习笔记

一、多线程支持模块：

_thread（不推荐使用）
threading
queue

二、threading模块的对象：

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

1.Thread类：

Thread对象的属性和方法：

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

创建线程的方法：

1.创建Thread的实例，传给它一个函数

范例：

import threading
from time import sleep, ctime

loops = [4,2]

def loop(nloop, nsec):
    print("start loop " + str(nloop) + " at: " + str(ctime()))
    sleep(nsec)
    print("loop " + str(nloop) + " done at: " + str(ctime()))

if __name__=="__main__":
    print("starting at: " + str(ctime()))
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = threading.Thread(target=loop,args=(i, loops[i]))
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print("all DONE at: " + str(ctime()))

2.创建Thread的实例，传给它一个可调用的类实例

范例：

import threading
from time import sleep, ctime

loops = [4,2]

class ThreadFunc(object):
    def __init__(self, func, args, name=" "):
        self.name = name
        self.func = func
        self.args = args

    def __call__(self):
        self.func(*self.args)

def loop(nloop, nsec):
    print("start loop " + str(nloop) + " at: " + str(ctime()))
    sleep(nsec)
    print("loop " + str(nloop) + " done at: " + str(ctime()))

if __name__=="__main__":
    print("starting at: " + str(ctime()))
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print("all DONE at: " + str(ctime()))

3.派生Thread的子类，并创建子类的实例

范例：

import threading
from time import sleep, ctime

loops = (4,2)

class MyThread(threading.Thread):
    def __init__(self, func, args, name=" "):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args

    def run(self):
        self.func(*self.args)

def loop(nloop, nsec):
    print("Start loop " + str(nloop) + " at:",ctime())
    sleep(nsec)
    print("loop " + str(nloop) + " done at:",ctime())
    
if __name__ == "__main__":
    print("starting at:", ctime())
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = MyThread(loop, (i, loops[i]), loop.__name__)
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print("all DONE at:", ctime())

2.threading模块的其他函数

函数对象	描述
activeCount()	返回当前活动的Thread对象个数
currentThread()	返回当前的Thread对象
enumerate()	返回当前活动的Thread对象列表
settrace(func)	为所有线程设置一个trace函数
setprofile(func)	为所有线程设置一个profile函数
stack_size(size=0)	返回新创建的线程的栈大小；或为后续创建线程设定栈的大小为size

三、同步

1.锁

锁的两种状态：锁定和未锁定

锁对象：Lock（或RLock）

获得锁：acquire()

释放锁：release()

多线程争夺锁时，允许第一个获得锁的线程进入临界区，并执行代码。之后所有到达的线程将被阻塞，直到第一个线程执行结束，退出临界区，并释放锁。此时其他等待的线程中随机一个（可根据Python实现的不同而有所区别）可以获得锁并进入临界区。

范例：

from atexit import register
from random import randrange
from threading import Thread, Lock, currentThread
from time import sleep, ctime

class CleanOutputSet(set):
    def __str__(self):
        return ", ".join(x for x in self)

lock = Lock()
loops = (randrange(2,5) for x in range(randrange(3,7)))
remaining = CleanOutputSet()

def loop(nsec):
    myname = currentThread().name
    lock.acquire()
    remaining.add(myname)
    print("[%s] Started %s" % (ctime(), myname))
    lock.release()
    sleep(nsec)
    lock.acquire()
    remaining.remove(myname)
    print("[%s] Completed %s (%d secs)" % (ctime(), myname, nsec))
    print("    (remaining: %s)" % (remaining or "NONE"))
    lock.release()

if __name__ == "__main__":
    for pause in loops:
        Thread(target=loop, args=(pause,)).start()

@register
def _atexit():
    print("all DONE at: ",ctime())

上下文管理：

使用with语句，此时每个上下文管理器负责在进入该语句块前调用acquire()并在执行之后调用release()

范例：

from atexit import register
from random import randrange
from threading import Thread, Lock, currentThread
from time import sleep, ctime

class CleanOutputSet(set):
    def __str__(self):
        return ", ".join(x for x in self)

lock = Lock()
loops = (randrange(2,5) for x in range(randrange(3,7)))
remaining = CleanOutputSet()

def loop(nsec):
    myname = currentThread().name
    with lock:
        remaining.add(myname)
        print("[%s] Started %s" % (ctime(), myname))

    sleep(nsec)
    with lock:
        remaining.remove(myname)
        print("[%s] Completed %s (%d secs)" % (ctime(), myname, nsec))
        print("    (remaining: %s)" % (remaining or "NONE"))

if __name__ == "__main__":
    for pause in loops:
        Thread(target=loop, args=(pause,)).start()

@register
def _atexit():
    print("all DONE at: ",ctime())

2.信号量

信号量是一个计数器，当资源消耗时递减，资源释放时递增，如果没有可用资源时消耗资源会被阻塞。

信号量对象：Semaphore（或BoundedSemaphore）

资源释放：release()

资源消耗：acquire()

范例：

#使用锁和信号量来模拟一个糖果机
from atexit import register
from random import randrange
from threading import BoundedSemaphore, Lock, Thread
from time import sleep, ctime

lock = Lock()
MAX = 5
candytray = BoundedSemaphore(MAX)

def refill():
    with lock:
        print("Refilling candy...")
        try:
            candytray.release()
        except ValueError:
            print("full, skipping")
        else:
            print("OK")

def buy():
    with lock:
        print("Buying candy...")
        if candytray.acquire(False):
            print("OK")
        else:
            print("Empty, skipping")

def produce(loops):
    for i in range(loops):
        refill()
        sleep(randrange(3))

def consumer(loops):
    for i in range(loops):
        buy()
        sleep(randrange(3))

if __name__ == "__main__":
    print("Starting at: ", ctime())
    nloops = randrange(2, 6)
    print("THE CANDY MACHINE (full with %d bars)!" % MAX)
    Thread(target=consumer, args=(randrange(nloops, nloops+MAX+2),)).start()
    Thread(target=produce, args=(nloops,)).start()

@register
def _atexit():
    print("all DONE at: ",ctime())

四、queue模块

1.queue模块

常用属性：

属性	描述
类
Queue(maxsize=0)	创建一个先入先出的队列。如果给定最大值，则在队列没有空间时阻塞；否则为无限队列
LifoQueue(maxsize=0)	创建一个后入先出的队列。如果给定最大值，则在队列没有空间时阻塞；否则为无限队列
PriorityQueue(maxsize=0)	创建一个优先级队列。如果给定最大值，则在队列没有空间时阻塞；否则为无限队列
异常
Empty	当对空队列调用get*()方法时抛出异常
Full	当对已满的队列调用put*()方法时抛出异常
queue对象方法
qsize()	返回队列大小（由于返回时队列大小可能被其他线程修改，所以该值为近似值）
empty()	如果队列为空，则返回True；否则，返回False
full()	如果队列为满，则返回True；否则，返回False
put(item, block=True,timeout=None)	将item放入队列。如果block为True（默认）且timeout为 None，则在有可用空间之前阻塞；如果timeout为正值，则最多阻塞timeout秒；如果block为False，则抛出Empty异常
put_nowait(item)	和put(item, False)相同
get(block=True, timeout=None)	从对列中取得元素。如果给定了block(非0)，则一直阻塞到有可用的元素为止
get_nowait()	和get(False)相同
task_done()	用于表示对列中某个元素已执行完成，该方法会被下面的join()使用
join()	在队列中所有元素执行完毕并调用上面的task_done()信号之前，保持阻塞

2.队列范例及生产者-消费者问题

import threading
from random import randint
from time import sleep, ctime
from queue import Queue

class MyThread(threading.Thread):
    def __init__(self, func, args, name=""):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args

    def run(self):
        print("starting",self.name,"at:",ctime())
        self.res = self.func(*self.args)
        print(self.name, "finished at:",ctime())

    def getResult(self):
        return self.res

def writeQ(queue):
    print("producing object for Q...")
    queue.put("xxx",1)
    print("size now", queue.qsize())

def readQ(queue):
    val = queue.get(1)
    print("consumed object from Q... size now", queue.qsize())

def writer(queue, loops):
    for i in range(loops):
        writeQ(queue)
        sleep(randint(1,3))

def reader(queue, loops):
    for i in range(loops):
        readQ(queue)
        sleep(randint(2,5))

funcs = [writer,reader]
nfuncs = range(len(funcs))

if __name__ == "__main__":
    nloops = randint(2,5)
    q = Queue(32)
    threads = []

    for i in nfuncs:
        t = MyThread(funcs[i],(q, nloops), funcs[i].__name__)
        threads.append(t)

    for i in nfuncs:
        threads[i].start()

    for i in nfuncs:
        threads[i].join()

        print("all Done")

五、高级线程模块concurrent.futures

concurrent.futures主要用于管理并发任务池。