多线程
- threading模块提供 Thread类和各种同步原语,用于编写多线程的程序。
Thread对象
- Thread类用于表示单独的控制线程。使用下面的函数可以创建一个新线程。
- Thread(group=None, target=None, namesNone, args=(), kwargs=())
- Group的值是None,为以后的扩展而保留。
- target是一个可调用对象,线程启动时,run(方法将调用此对象,它的默认值是None,表示不调用任何内容。
- name是线程名称。默认将创建一个" Thread-N格式的唯一名称。
- args是传递给 target函数的参数元组。
- kwargs是传递给 target的关键字参数的字典。
Thread实例t支持以下方法和属性。
-
t.start():通过在一个单独的控制线程中调用run()方法,启动线程。此方法只能调用一次。
-
t.run():线程启动时将调用此方法。默认情况下,它将调用传递到构造函数中的目标函数。还可以在 Thread的子类中重新定义此方法。
-
t.join([timeout]):等待直到线程终止或者出现超时为止。 timeout是一个浮点数,用于指定以秒为单位的超时时间。线程不能连接自身,而且在线程启动之前就连接它将出现错误。
-
t.is_alive():如果线程是活动的,返回rue,否则返回 False。从 start()方法返回的那一刻开始,线程就是活动的,直到它的run()方法终止为止。
-
t.name:线程名称
-
t.ident:整数线程标识符。如果线程尚未启动,它的值为None。
-
t.daemon:线程的布尔型后台标志。必须在调用 start()方法之前设置这个标志,它的初始值从创建线程的
后台状态继承而来。当不存在任何活动的非后台线程时,整个 Python程序将退出。所有程序都有一个
主线程,代表初始的控制线程,它不是后台线程。
- 如何以线程的形式创建和启动一个函数(或其他可调用对象)
直接调用线程：
import threading
import time
def sayhi(num):
print("启动第几个：%s"%num)
time.sleep(3)
if __name__ == '__main__':
t1 = threading.Thread(target=sayhi,args=(1,))
t2 = threading.Thread(target=sayhi,args=(2,))
t1.start()
t2.start()
print(t1.getName())
print(t2.getName())
继承式调用：
import threading
import time
class myThread():
def __init__(self,num):
threading.Thread.__init__(self)
self.num = num
def run(self):
print("启动第几个：%s" %self.num)
time.sleep(3)
if __name__ == '__main__':
t1 = myThread(1)
t2 = myThread(2)
t1.run()
t2.run()
Timer对象
- Timer对象用于在稍后的某个时间执行一个函数。
- Timer(interval, func [, args [, kwargs]])
- 创建定时器对象,在过去 interval秒时间之后运行函数 func. args和 kwargs提供传递给func的参数和关键字参数。在调用 start()方法后才会启动定时器。
- Timer对象t具有以下方法。
- t.start:启动定时器。提供给Timer()方法的函数func将在指定的时间间隔之后执行。
- t.cancel():如果函数尚未执行,取消定时器
Lock对象
- 互斥锁，两个方法 acquire()和 releaseω)用于修改锁的状态。如果状态为已锁定,尝试获取锁将被阻塞,直到锁被释放为止。如果有多个线程等待获取锁,当锁被释放时,只有一个线程能获得它。等待线程获得锁的顺序没有定义。
- 使用下面的构造函数可以创建新的Lock实例:
lock = thraeding.Lock() - 创建新的Lock对象,初始状态为未锁定。
- Lock实例1ock支持以下方法。
- lock.acquire([blocking 1):获取锁,如果有必要,需要阻塞到锁释放为止。如果提供 blocking参数并将它设为 False,当无法获取锁时将立即返回 False,如果成功获取锁则返回True。
- lock.release()
- 释放一个锁。当锁处于未锁定状态时,或者从与原本调用 acquire()方法的线程不同的线程调用此方法,将出现错误。
Rlock对象
- 可重入锁是一个类似于Lock对象的同步原语,但同一个线程可以多次获取它。这允许拥有锁的线程执行嵌套的 acquire()和 release()操作。在这种情况下,只有最外面的 release()操作才能将锁重置为未锁定状态。
使用下面的构造函数可以创建一个新的 RLock对象:
rlock = threading.RLock()
- 创建新的可重入锁对象。 RLock对象 rlock支持以下方法。
- rlock.acquire([blocking 1):获取锁,如果有必要,需要阻塞到锁被释放为止。如果没有线程拥有锁,它将被锁定,而且递归级别被置为1。如果此线程已经拥有锁,锁的递归级别加1,而且函数立即返回.
- rlock.release()通过减少锁的递归级别来释放它。如果在减值后递归级别为0,锁将被重置为未锁定状态。否则,锁将保持已锁定状态。只能由目前拥有锁的线程来调用此函数。
信号量
- 信号量是一个基于计数器的同步原语,每次调用 acquire()方法时此计数器减1,每次调用release()方法时此计数器加1。如果计数器为0, acquire()方法将会阻塞,直到其他线程调用re1ease()方法为止。
- Semaphore([value])
- 创建一个新的信号量。ⅴa1ve是计数器的初始值。如果省略此参数,计数器的值将被置为l。
s = threading.Semaphore()
- Semaphore实例s支持以下方法。
- s.acquire([blocking]):获取信号量。如果进入时内部计数器大于0,此方法将把它的值减1,然后立即返回。如果它的值为0,此方法将阻塞,直到另一个线程调用 release()方法为止。 blocking参数的行为与Lock和 RLock
对象中描述的相同。 - s.release()通过将内部计数器的值加1来释放一个信号量。如果计数器为0,而且另一个线程正在等待,该线程将被唤醒。如果有多个线程正在等待,只能从它的acquire(调用返回其中一个。线程释放的顺序并不确定。
有边界的信号量
- BoundedSemaphore([value])
- 创建一个新的信号量。va1ue是计数器的初始值。如果省略此参数,计数器的值将被置为1。
- BoundedSemaphore的工作方式与 Semaphore完全相同,但 release()操作的次数不能超过 acquire()操作的次数
- 信号量与互斥锁之间的微妙差别在于:信号量可用于发信号。例如,可以从不同线程调用 acquire()和 release()方法,以便在生产者和消费者线程之间进行通信。
事件
- 事件用于在线程之间通信。一个线程发出“事件”信号,一个或多个其他线程等待它。Event实例管理着一个内部标志,可以使用set()方法将它置为rue,或者使用 clear()方法将它重置为 False,wait()方法将阻塞,直到标志为Ture。
e = threading.Event()
- 创建新的 Event实例,并将内部标志置为Fa1se。Event实例e支持以下方法。
- e.is_set():只有当内部标志为True时才返回True。
- e.set():将内部标志置为rue。等待它变为True的所有线程都将被唤醒。
- e.clear():将内部标志重置为Fase。
- e.wait([timeout]):阻塞直到内部标志为rue。如果进入时内部标志为rue,此方法将立即返回。否则,它将阻塞,直到另一个线程调用set()方法将标志置为True,或者直到出现可选的超时。 timeout是一个浮点数,
用于指定以秒为单位的超时期限。 - 尽管 Event对象可用于给其他线程发信号,但不应该使用它们来实现在生产者/消费者问题中十分典型的通知。
条件变量
- 当需要线程关注特定的状态变化或事件的发生时将使用这个锁。典型的用法是生产者-消费者问题,其中一个线程生产的数据供另一个线程使用。
- 使用下面的构造函数可以创建新的 Condition实例:
- Condition([lock])
- 创建新的条件变量。lock是可选的Lock或RLock实例。如果未提供lock参数,就会创建新的RLock实例供条件变量使用。
cv = threading.Condition()
- 条件变量cv支持以下方法。
cv.acquire(*args):获取底层锁。此方法将调用底层锁上对应的 acquire(*args)方法。- cv.release():释放底层锁。此方法将调用底层锁上对应的 release()方法。
- cv.wait([timeout]):等待直到获得通知或出现超时为止。此方法在调用线程已经获取锁之后调用。调用时,将释放底层锁,而且线程将进入睡眠状态,直到另一个线程在条件变量上执行 notify(或 notify110)方法将其唤醒为止。在线程被唤醒之后,线程将重新获取锁,方法也会返回。timeout是浮点数,单位为秒。如果这段时限耗尽,线程将被唤醒,重新获取锁,而控制将被返回
- cv.notify([n]):唤醒一个或多个等待此条件变量的线程。此方法只会在调用线程已经获取锁之后调用,而且如果没有正在等待的线程,它就什么也不做。n指定要唤醒的线程数量,默认为1。被唤醒的线程在它们重新获取锁之前不会从wait()调用返回.
- cv.notify_all():唤醒所有等待此条件的线程。
queue
- queue模块实现了各种多生产者-多消费者队列,可用于在执行的多个线
程之间安全地交换信息。 - queue模块定义了3种不同的队列类。
Queue([maxsize])
创建一个FFO( first- in first-out,先进先出)队列。 maXsize是队列中可以放入的项的最大数量。
如果省略 maxsize参数或将它置为0,队列大小将为无穷大。
Lifoqueue([maxsize])
创建一个LIFO( last-in first-out,后进先出)队列(也叫栈)。
Priorityqueue([maxsize])
创建一个优先级队列,其中项按照优先级从低到高依次排好。使用这种队列时,项应该是(priority,data)形式的元组,其中 priority是一个数字。
import queue
q = queue()
- 队列类的实例q具有以下方法。
- q.qsize():返回队列的正确大小。因为其他线程可能正在更新队列,此方法返回的数字不完全可靠。
- q.empty():如果队列为空,返回True,否则返回Fa1se。
- q.full():如果队列已满,返回rue,否则返回 False。
- q.put(item [block [,timeout]]):将item放入队列。如果可选参数bock为True(默认值),调用者将被阻塞直到队列中出现可用的空闲位置为止。否则(block为 False),队列满时将引发Full异常。timeout提供可选的超时值,单位为秒。如果出现超时,将引发Full异常。
- q.put_nowait(item):等价于q.put(item, False)方法。
- q.get([block [,timeout]]):从队列中删除一项,然后返回这个项。如果可选参数blok为rue(默认值),调用者将阻塞,直到队列中出现可用的空闲位置。否则(block为False),队列为空时将引发Empty异常。timeout提供可选的超时值,单位为秒。如果出现超时,将引发Empty异常。
- q.get_nowait():等价于get(0)方法
- q.task_done():队列中数据的消费者用来指示对于项的处理已经结束。如果使用此方法,那么从队列中删除的每一项都应该调用一次。
- q.join():阻塞直到队列中的所有项均被删除和处理为止。一旦为队列中的每一项都调用了一次q. task done()方法,此方法将会直接返回。
使用队列的线程示例
import threading
from queue import Queue
class WorkerThread(threading.Thread):
def __init__(self,*args, **kwargs):
threading.Thread.__init__(self, *args, **kwargs)
self.input_queue= Queue()
def send(self, item):
self.input_queue.put(item)
def close(self):
self.input_queue.put(None)
self.input_queue. oin()
def run(self):
while True:
item = self.input_queue.get()
if item is None:
break
print(item)
self.input_queue.task_done()
self.input_queue.task_done()
return
if __name__ == '__main__':
w = WorkerThread()
w.start()
w.send('hello')
w.send("world")
w.close()
多线程共享全局变量的问题：
多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是可共享的。这就造成了一个问题，因为线程执行的顺序是无序的。有可能会造成数据错误
解决方案：锁机制
为了解决以上使用共享全局变量的问题。threading提供了一个Lock类，这个类可以在某个线程访问某个变量的时候加锁，其他线程此时就不能进来，直到当前线程处理完后，把锁释放了，其他线程才能进来处理。
秋来凉风起，无限思远人
