Python-多线程

多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理（Chip-level multithreading）或同时多线程（Simultaneous multithreading）处理器。[1] 在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理（Multithreading）”。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程（台湾译作“执行绪”），进而提升整体处理性能。

Threading

创建并启动一个线程

import threading

def runtask(name):
    print("%s线程已启动"%name)

t = threading.Thread(target=runtask,args=("task1",))    # args因为是一个元组，所以必须这样写,否则运行将报错
t.start()

join

等待当前线程执行完毕

import threading
import time

def runtask(name):
    print("%s线程已启动"%name)
    time.sleep(2)

t = threading.Thread(target=runtask,args=("task1",))    
t.start()
t.join()
print("abc")    # 过了2s才会打印，若无等待将看不到等待2s的效果

setDaemon(True)

将线程设置为守护线程。若设置为守护线程，主线程结束后，子线程也将结束，并且主线程不会理会子线程是否结束，主线程不会等待子线程结束完后才结束。若没有设置为守护线程，主线程会等待子线程结束后才会结束。

active_count

程序的线程数量，数量=主线程+子线程数量

Lock(互斥锁)

Python编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为” 互斥锁” 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。在Python中我们使用threading模块提供的Lock类。

import threading,time

def runtask(name):
    global count
    time.sleep(1)
    lock.acquire()      # 获取锁资源，并返回是否获取成功
    count+=1
    print(name,count)
    lock.release()      # 释放资源
    


count = 0
lock = threading.Lock()     # 互斥锁

for index in range(50):
    t = threading.Thread(target=runtask,args=("thread%d"%index,))
    t.start()

上面这段代码如果没有加上互斥锁，在Python2.x中执行的结果将会是乱的。在Python3.x中执行却总是正确的，似乎是自动为其加了锁

RLock(递归锁，可重入锁)

当一个线程中遇到锁嵌套情况该怎么办，又会遇到什么情况？

def run1():
    global count1
    lock.acquire()
    count1 += 1
    lock.release()
    return count1

def run2():
    global count2
    lock.acquire()
    count2 += 1
    lock.release()
    return count2

def runtask():
    lock.acquire()
    r1 = run1()
    print("="*30)
    r2 = run2()
    lock.release()
    print(r1,r2)

count1,count2 = 0,0
lock = threading.Lock()

for index in range(50):
    t = threading.Thread(target=runtask,)
    t.start()

这是一个很简单的线程锁死案例，程序将被卡死，停止不动。为了解决这一情况，Python提供了递归锁RLock(可重入锁)。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的代码只需做一些小小的改动

lock = threading.Lock() 
修改为:
lock = threading.RLock()

那么程序将不会发生死锁情况。

最大可执行线程

threading.BoundedSemaphore(5)设置可同时执行的最大线程数为5个，后面的线程需排队等待前面的线程执行完毕

import time,threading
def runtask(name):
    global num

    semaphore.acquire()
    time.sleep(1)
    num += 1
    semaphore.release()
    print(name,num)

num = 0
semaphore = threading.BoundedSemaphore(5)

for index in range(50):
    t = threading.Thread(target=runtask,args=("线程%s"%index,))
    t.start()

执行效果:

可以看出上面的程序是每次只有5个线程在同时运行，其他线程需等待前面的线程执行完毕,这就是最大可执行线程。

Event

Python提供了Event对象用于线程间通信，它是由线程设置的信号标志，如果信号标志位为假，则线程等待直到信号被其他线程设置成真。Event中提供了四个重要的方法来满足基本的需求。

• clear：清除标记
• set：设置标记
• is_set：是否被标记
• wait：等待被标记
  代码示例：

import threading,time
def lighter():
    num = 0
    event.set()     # 设置标记
    while True:
        if num >= 5 and num < 10:
            event.clear()   # 清除标记
            print("红灯亮起，车辆禁止通行")
        if num >= 10:
            event.set()     # 设置标记
            print("绿灯亮起，车辆可以通行")
            num = 0
        num += 1
        time.sleep(1)
        
def car():
    while True:
        if event.is_set():
            print("车辆正在跑...")
        else:
            print("车辆停下了")
            event.wait()
            
        time.sleep(1)
        
event = threading.Event()
t1 = threading.Thread(target=lighter,)
t2 = threading.Thread(target=car,)
t1.start()
t2.start()

这是一个简单的红灯停绿灯行案例。初始设置为绿灯并标记，车辆看到标记后通行，当红灯亮起的时候取消标记，车辆看到没有标记时停下，等待标记。

Queue队列

常见类

Queue

Queue(maxsize=0)先进先出队列。maxsize是一个整数，用于设置可以放入队列的项目数上限！达到此大小后，插入即阻止！maxsize小于或等于0，那么表示此队列为无限大！举个栗子：

from queue import Queue
from threading import Thread

q = Queue()
def thread_task(name):
    q.put("name: {}".format(name))
    
def get_task():
    while True:
        if q.empty():
            break
        t = q.get()
        print(t)
        
if __name__ == "__main__":
    t1 = Thread(target=thread_task, args=('laozhang', ))
    t2 = Thread(target=thread_task, args=('laowang', ))
    t3 = Thread(target=thread_task, args=('laoli', ))
    t1.start()
    t2.start()
    t3.start()
    get_task()
    
############### 运行之后，将打印结果如下 ###############
name: laozhang
name: laowang
name: laoli

LifoQueue

LifoQueue(maxsize=0)先进后出队列。maxsize是一个整数，用于设置可以放入队列的项目数上限！达到此大小后，插入即阻止！maxsize小于或等于0，那么表示此队列为无限大！举个栗子：

from queue import LifoQueue
from threading import Thread

q = LifoQueue()
def thread_task(name):
    q.put("name: {}".format(name))
    
def get_task():
    while True:
        if q.empty():
            break
        t = q.get()
        print(t)
        
if __name__ == "__main__":
    t1 = Thread(target=thread_task, args=('laozhang', ))
    t2 = Thread(target=thread_task, args=('laowang', ))
    t3 = Thread(target=thread_task, args=('laoli', ))
    t1.start()
    t2.start()
    t3.start()
    get_task()
    
############### 运行之后，将打印结果如下 ###############
name: laoli
name: laowang
name: laozhang

PriorityQueue

PriorityQueue(maxsize=0)优先级队列，优先级的值越小，越先执行！"项目"的形式是一个元组：（priority_number, data），priority_number为优先级数值！maxsize是一个整数，用于设置可以放入队列的项目数上限！达到此大小后，插入即阻止！maxsize小于或等于0，那么表示此队列为无限大！举个栗子：

from threading import Thread
from queue import PriorityQueue

q = PriorityQueue()
def thread_task(priority_num, name):
    arg = (priority_num, name)
    q.put(arg)
    
def get_task():
    while True:
        if q.empty():
            break
        t = q.get()
        print(t)
        
if __name__ == "__main__":
    t1 = Thread(target=thread_task, args=(2, 'laozhang', ))
    t2 = Thread(target=thread_task, args=(1, 'laowang', ))
    t3 = Thread(target=thread_task, args=(3, 'laoli', ))
    t1.start()
    t2.start()
    t3.start()
    get_task()
    
############### 运行之后，将打印结果如下 ###############
(1, 'laowang')
(2, 'laozhang')
(3, 'laoli')

常用方法

qsize

qsize()返回队列的大致大小。值得注意的是，qsize() > 0不保证后续的get()操作不会阻塞；qsize() < maxsize也不保证put()操作不会阻塞！

empty

empty()判断队列是否为空，True为空，False不为空。返回True情况下，不保证后续的put()操作不会阻塞；返回False情况下，也不保证get()操作不会阻塞！

full

full()判断队列是否满了，True表示已满，False表示未满。返回True情况下，不保证后续的get()操作不会阻塞；返回False情况下，也不保证put()操作不会阻塞！

put

put(item, block=True, timeout=None)将项目放入队列。如果block=True并且timeout=None，则在必要时阻塞，知道有可用的插槽。block为False时，将不会阻塞，如果有可用插槽立即使用，否则将引发queue.Full异常！timeout为正数，并且block=True，如果在timeout秒时间内没有可用的插槽，将会引发异常！

put_nowait

put_nowait(item)等同于put(item, block=False)

get

get(block=True, timeout=None)从队列中删除并返回一个项目。如果block=True则在必要时阻塞，知道有可用的插槽为止。timeout为正数时，最多会阻塞timeout秒，如果在该时间段内没有获取到可用的选项将会引发异常。如果block=False，如果有立即可用的项，则返回一个项，否则引发Empty异常

get_nowait

get_nowait()等同于get(block=False)

task_done

task_done()表示先前排队任务已完成。对于用于获取任务的每个get()，后续调用task_done()告诉该队列任务的处理已完成

join

join()阻塞直到队列中的所有项目都已获得并处理

import time
import threading
from queue import Queue

q = Queue()

def do_worker():
    print(time.time())
    time.sleep(1)
    t = q.get()
    print(time.time(), t, q.qsize())
    q.task_done()

for item in range(5):
    t = threading.Thread(target=do_worker)
    t.start()
    
for item in range(10):
    q.put("item-{}".format(item))

print("queue start")
q.join()
print("queue end")

运行打印结果如下：

1577166965.318283
1577166965.318443
1577166965.318599
1577166965.318763
1577166965.318885
queue start
1577166966.323134 item-0 9
1577166966.323447 item-1 8
1577166966.323668 item-2 7
1577166966.324207 item-3 6
1577166966.324689 item-4 5