Python 3 - 多线程编程

运行多个线程类似于同时运行多个不同的程序，但具有以下优点 :

• 多个线程在一个进程内与主线程共享相同的数据空间，因此可以比它们是单独的进程更容易地共享信息或相互通信.

• 线程有时称为轻量级进程，它们不需要太多内存开销;它们比流程便宜.

线程有一个开头，一个执行序列和一个结论.它有一个指令指针，可以跟踪当前运行的上下文.

• 它可以被抢占(中断).

• 当其他线程正在运行时，它可以暂时被搁置(也称为休眠) - 这称为让步.

有两种不同类型的线程 :

• 内核线程

• 用户线程

内核线程是操作系统的一部分，而用户空间线程没有在内核中实现.

有两个模块支持Python3中的线程使用 :

• _thread

• threading

线程模块已被"弃用"了很长时间.建议用户使用线程模块.因此，在Python 3中，模块"thread"不再可用.但是，它已经被重命名为"_thread"，用于Python3中的向后兼容性.

开始新线程

要生成另一个线程，需要在线程模块中调用以下方法 :

_thread.start_new_thread ( function, args[, kwargs] )

此方法调用可以快速有效地在Linux和Windows中创建新线程.

方法调用立即返回，子线程启动并使用传递的列表调用函数 args 当函数返回时，线程终止.

这里， args 是一个参数元组;使用空元组来调用函数而不传递任何参数. kwargs 是关键字参数的可选字典.

示例

#!/usr/bin/python3import _threadimport time# Define a function for the threaddef print_time( threadName, delay):   count = 0   while count < 5:      time.sleep(delay)      count += 1      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))# Create two threads as followstry:   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )except:   print ("Error: unable to start thread")while 1:   pass

输出

执行上述代码时，会产生以下结果 :

Thread-1: Fri Feb 19 09:41:39 2016Thread-2: Fri Feb 19 09:41:41 2016Thread-1: Fri Feb 19 09:41:41 2016Thread-1: Fri Feb 19 09:41:43 2016Thread-2: Fri Feb 19 09:41:45 2016Thread-1: Fri Feb 19 09:41:45 2016Thread-1: Fri Feb 19 09:41:47 2016Thread-2: Fri Feb 19 09:41:49 2016Thread-2: Fri Feb 19 09:41:53 2016

程序进入无限循环.您必须按ctrl-c才能停止

虽然它对于低级线程非常有效，但线程模块与较新的线程相比非常有限模块.

线程模块

Python 2.4中包含的新线程模块为线程提供了比线程模块更强大，更高级的支持在上一节中讨论过.

线程模块公开了线程模块的所有方法，并提供了一些额外的方法 :

• threading.activeCount() : 返回活动的线程对象的数量.

• threading.currentThread() : 返回调用者线程控件中线程对象的数量.

• threading.enumerate() : 返回当前活动的所有线程对象的列表.

除了方法之外，线程模块还有线程实现线程的类. Thread 类提供的方法如下 :

• run( ) :  run()方法是线程的入口点.

• start() :  start()方法通过调用run方法启动一个线程.

• join([time]) :  join()等待线程终止.

• isAlive() :  isAlive()方法检查线程是否仍在执行.

• getName() :  getName()方法返回一个线程的名称.

• setName() :  setName()方法设置线程的名称.

使用线程模块创建线程

要使用线程模块实现新线程，您必须执行以下操作 :

• 定义新的子类线程类.

• 覆盖 __ init __(self [，args])方法以添加额外的参数.

• 然后，重写run(self [，args])方法以实现线程在启动时应该执行的操作.

创建新的 Thread 子类后，可以创建它的实例，然后通过调用

示例

#!/usr/bin/python3import threadingimport timeexitFlag = 0class myThread (threading.Thread):   def __init__(self, threadID, name, counter):      threading.Thread.__init__(self)      self.threadID = threadID      self.name = name      self.counter = counter   def run(self):      print ("Starting " + self.name)      print_time(self.name, self.counter, 5)      print ("Exiting " + self.name)def print_time(threadName, delay, counter):   while counter:      if exitFlag:         threadName.exit()      time.sleep(delay)      print ("%s: %s" % (threadName, time.ctime(time.time())))      counter -= 1# Create new threadsthread1 = myThread(1, "Thread-1", 1)thread2 = myThread(2, "Thread-2", 2)# Start new Threadsthread1.start()thread2.start()thread1.join()thread2.join()print ("Exiting Main Thread")

结果

当我们运行上述程序时，它会产生以下结果 :

Starting Thread-1Starting Thread-2Thread-1: Fri Feb 19 10:00:21 2016Thread-2: Fri Feb 19 10:00:22 2016Thread-1: Fri Feb 19 10:00:22 2016Thread-1: Fri Feb 19 10:00:23 2016Thread-2: Fri Feb 19 10:00:24 2016Thread-1: Fri Feb 19 10:00:24 2016Thread-1: Fri Feb 19 10:00:25 2016Exiting Thread-1Thread-2: Fri Feb 19 10:00:26 2016Thread-2: Fri Feb 19 10:00:28 2016Thread-2: Fri Feb 19 10:00:30 2016Exiting Thread-2Exiting Main Thread

同步线程

Python提供的线程模块包含一个易于实现的锁定机制允许您同步线程.通过调用 Lock()方法创建一个新锁，该方法返回新锁.

获取(阻塞)方法新的锁对象用于强制线程同步运行.可选的 blocking 参数使您可以控制线程是否等待获取锁定.

如果阻止设置为0，则如果无法获取锁，则线程立即返回0值，如果获取了锁，则返回1.如果阻塞设置为1，则线程会阻塞并等待锁被释放.

新锁对象的 release()方法用于在不再需要时释放锁.

示例

#!/usr/bin/python3import threadingimport timeclass myThread (threading.Thread):   def __init__(self, threadID, name, counter):      threading.Thread.__init__(self)      self.threadID = threadID      self.name = name      self.counter = counter   def run(self):      print ("Starting " + self.name)      # Get lock to synchronize threads      threadLock.acquire()      print_time(self.name, self.counter, 3)      # Free lock to release next thread      threadLock.release()def print_time(threadName, delay, counter):   while counter:      time.sleep(delay)      print ("%s: %s" % (threadName, time.ctime(time.time())))      counter -= 1threadLock = threading.Lock()threads = []# Create new threadsthread1 = myThread(1, "Thread-1", 1)thread2 = myThread(2, "Thread-2", 2)# Start new Threadsthread1.start()thread2.start()# Add threads to thread listthreads.append(thread1)threads.append(thread2)# Wait for all threads to completefor t in threads:   t.join()print ("Exiting Main Thread")

输出

执行上述代码时，会产生以下结果 :

Starting Thread-1Starting Thread-2Thread-1: Fri Feb 19 10:04:14 2016Thread-1: Fri Feb 19 10:04:15 2016Thread-1: Fri Feb 19 10:04:16 2016Thread-2: Fri Feb 19 10:04:18 2016Thread-2: Fri Feb 19 10:04:20 2016Thread-2: Fri Feb 19 10:04:22 2016Exiting Main Thread

多线程优先级队列

队列模块允许您创建一个可以容纳特定号码的新队列对象的项目.有以下方法来控制队列和减号;

• get() :  get()从队列中删除并返回一个项目.

• put() :  put将项目添加到队列中.

• qsize() :  qsize()返回当前队列中的项目数.

• empty() : 如果队列为空，则empty()返回True;否则，错误.

• full() : 如果队列已满，则full()返回True;否则，错误.

示例

#!/usr/bin/python3import queueimport threadingimport timeexitFlag = 0class myThread (threading.Thread):   def __init__(self, threadID, name, q):      threading.Thread.__init__(self)      self.threadID = threadID      self.name = name      self.q = q   def run(self):      print ("Starting " + self.name)      process_data(self.name, self.q)      print ("Exiting " + self.name)def process_data(threadName, q):   while not exitFlag:      queueLock.acquire()      if not workQueue.empty():         data = q.get()         queueLock.release()         print ("%s processing %s" % (threadName, data))      else:         queueLock.release()         time.sleep(1)threadList = ["Thread-1", "Thread-2", "Thread-3"]nameList = ["One", "Two", "Three", "Four", "Five"]queueLock = threading.Lock()workQueue = queue.Queue(10)threads = []threadID = 1# Create new threadsfor tName in threadList:   thread = myThread(threadID, tName, workQueue)   thread.start()   threads.append(thread)   threadID += 1# Fill the queuequeueLock.acquire()for word in nameList:   workQueue.put(word)queueLock.release()# Wait for queue to emptywhile not workQueue.empty():   pass# Notify threads it's time to exitexitFlag = 1# Wait for all threads to completefor t in threads:   t.join()print ("Exiting Main Thread")

输出

当执行上面的代码时，它产生以下结果 :

Starting Thread-1Starting Thread-2Starting Thread-3Thread-1 processing OneThread-2 processing TwoThread-3 processing ThreeThread-1 processing FourThread-2 processing FiveExiting Thread-3Exiting Thread-1Exiting Thread-2Exiting Main Thread