Python 系列(15) 多线程

Posted on Posted in python

### thread 线程模块

Python中使用线程有两种方式:函数或者用类来包装线程对象。
函数式:调用thread模块中的start_new_thread()函数来产生新线程。语法如下:

  1. thread.start_new_thread ( function, args[, kwargs] )  

- function - 线程函数。
- args - 传递给线程函数的参数,他必须是个tuple类型。
- kwargs - 可选参数。

  1. #!/usr/bin/python  
  2. # -*- coding: UTF-8 -*-  
  3.   
  4. import thread  
  5. import time  
  6.   
  7. # 为线程定义一个函数  
  8. def print_time( threadName, delay):  
  9.    count = 0  
  10.    while count < 5:  
  11.       time.sleep(delay)  
  12.       count += 1  
  13.       print "%s: %s" % ( threadName, time.ctime(time.time()) )  
  14.   
  15. # 创建两个线程  
  16. try:  
  17.    thread.start_new_thread( print_time, ("Thread-1", 2, ) ) # 元祖元素作为参数传进print_time  
  18.    thread.start_new_thread( print_time, ("Thread-2", 4, ) )  
  19. except:  
  20.    print "Error: unable to start thread"  
  21.   
  22. while 1:  
  23.    pass  

Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。
thread 模块提供的其他方法:

- threading.currentThread(): 返回当前的线程变量。
- threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
- threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。

除了使用方法外,线程模块同样提供了Thread类来处理线程,Thread类提供了以下方法:

- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。

### Threading 线程模块

使用Threading模块创建线程,直接从threading.Thread继承,然后重写__init__方法和run方法:

  1. #!/usr/bin/python  
  2. # -*- coding: UTF-8 -*-  
  3.   
  4. import threading  
  5. import time  
  6.   
  7. exitFlag = 0  
  8.   
  9. class myThread (threading.Thread):   #继承父类threading.Thread  
  10.     def __init__(self, threadID, name, counter):  
  11.         threading.Thread.__init__(self)  
  12.         self.threadID = threadID  
  13.         self.name = name  
  14.         self.counter = counter  
  15.     def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数   
  16.         print "Starting " + self.name  
  17.         print_time(self.name, self.counter, 5)  
  18.         print "Exiting " + self.name  
  19.   
  20. def print_time(threadName, delay, counter):  
  21.     while counter:  
  22.         if exitFlag:  
  23.             thread.exit()  
  24.         time.sleep(delay)  
  25.         print "%s: %s" % (threadName, time.ctime(time.time()))  
  26.         counter -= 1  
  27.   
  28. # 创建新线程  
  29. thread1 = myThread(1, "Thread-1", 1)  
  30. thread2 = myThread(2, "Thread-2", 2)  
  31.   
  32. # 开启线程  
  33. thread1.start()  
  34. thread2.start()  
  35.   
  36. print "Exiting Main Thread"  

### 线程同步,线程锁

例子:

  1. loops = [4,2]  
  2. def loop(nloop,nsec,lock):  
  3.     print u"开始:\n\t",ctime()  
  4.     sleep(nsec)  
  5.     print u"loop",nloop,ctime()  
  6.     #lock.release()#释放锁  
  7. def loop2():  
  8.     print u"loop2开始: \n\t",ctime()  
  9.     locks = []  
  10.     nloops = range(len(loops))  
  11.     for i in nloops:#i= 0,1  
  12.         lock = thread.allocate_lock()#创建一个锁对象  
  13.         lock.acquire()#尝试获取所对象  
  14.         locks.append(lock)#把锁对象添加到列表当中  
  15.         thread.start_new_thread(loop,(i,loops[i],locks[i]))  
  16.     sleep(5)  
  17.     print '----all done-----',ctime()  
  18. loop2()  

如果多个线程共同对某个数据修改,则可能出现不可预料的结果,为了保证数据的正确性,需要对多个线程进行同步。
使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个对象都有acquire方法和release方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到acquire和release方法之间。如下:
多线程的优势在于可以同时运行多个任务(至少感觉起来是这样)。但是当线程需要共享数据时,可能存在数据不同步的问题。
考虑这样一种情况:一个列表里所有元素都是0,线程"set"从后向前把所有元素改成1,而线程"print"负责从前往后读取列表并打印。
那么,可能线程"set"开始改的时候,线程"print"便来打印列表了,输出就成了一半0一半1,这就是数据的不同步。为了避免这种情况,引入了锁的概念。
锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时,必须先获得锁定;如果已经有别的线程比如"print"获得锁定了,那么就让线程"set"暂停,也就是同步阻塞;等到线程"print"访问完毕,释放锁以后,再让线程"set"继续。
经过这样的处理,打印列表时要么全部输出0,要么全部输出1,不会再出现一半0一半1的尴尬场面。
实例:

  1. #!/usr/bin/python  
  2. # -*- coding: UTF-8 -*-  
  3.   
  4. import threading  
  5. import time  
  6.   
  7. class myThread (threading.Thread):  
  8.     def __init__(self, threadID, name, counter):  
  9.         threading.Thread.__init__(self)  
  10.         self.threadID = threadID  
  11.         self.name = name  
  12.         self.counter = counter  
  13.     def run(self):  
  14.         print "Starting " + self.name  
  15.        # 获得锁,成功获得锁定后返回True  
  16.        # 可选的timeout参数不填时将一直阻塞直到获得锁定  
  17.        # 否则超时后将返回False  
  18.         threadLock.acquire()  
  19.         print_time(self.name, self.counter, 3)  
  20.         # 释放锁  
  21.         threadLock.release()  
  22.   
  23. def print_time(threadName, delay, counter):  
  24.     while counter:  
  25.         time.sleep(delay)  
  26.         print "%s: %s" % (threadName, time.ctime(time.time()))  
  27.         counter -= 1  
  28.   
  29. threadLock = threading.Lock()  
  30. threads = []  
  31.   
  32. # 创建新线程  
  33. thread1 = myThread(1, "Thread-1", 1)  
  34. thread2 = myThread(2, "Thread-2", 2)  
  35.   
  36. # 开启新线程  
  37. thread1.start()  
  38. thread2.start()  
  39.   
  40. # 添加线程到线程列表  
  41. threads.append(thread1)  
  42. threads.append(thread2)  
  43.   
  44. # 等待所有线程完成  
  45. for t in threads:  
  46.     t.join()  
  47. print "Exiting Main Thread"  

### 线程优先级队列( Queue)

Python的Queue模块中提供了同步的、线程安全的队列类,包括FIFO(先入先出)队列Queue,LIFO(后入先出)队列LifoQueue,和优先级队列PriorityQueue。这些队列都实现了锁原语,能够在多线程中直接使用。可以使用队列来实现线程间的同步。
Queue模块中的常用方法:

- Queue.qsize() 返回队列的大小
- Queue.empty() 如果队列为空,返回True,反之False
- Queue.full() 如果队列满了,返回True,反之False
- Queue.full 与 maxsize 大小对应
- Queue.get([block[, timeout]])获取队列,timeout等待时间
- Queue.get_nowait() 相当Queue.get(False)
- Queue.put(item) 写入队列,timeout等待时间
- Queue.put_nowait(item) 相当Queue.put(item, False)
- Queue.task_done() 在完成一项工作之后,Queue.task_done()函数向任务已经完成的队列发送一个信号
- Queue.join() 实际上意味着等到队列为空,再执行别的操作

  1. #!/usr/bin/python  
  2. # -*- coding: UTF-8 -*-  
  3.   
  4. import Queue  
  5. import threading  
  6. import time  
  7.   
  8. exitFlag = 0  
  9.   
  10. class myThread (threading.Thread):  
  11.     def __init__(self, threadID, name, q):  
  12.         threading.Thread.__init__(self)  
  13.         self.threadID = threadID  
  14.         self.name = name  
  15.         self.q = q  
  16.     def run(self):  
  17.         print "Starting " + self.name  
  18.         process_data(self.name, self.q)  
  19.         print "Exiting " + self.name  
  20.   
  21. def process_data(threadName, q):  
  22.     while not exitFlag:  
  23.         queueLock.acquire()  
  24.         if not workQueue.empty():  
  25.             data = q.get()  
  26.             queueLock.release()  
  27.             print "%s processing %s" % (threadName, data)  
  28.         else:  
  29.             queueLock.release()  
  30.         time.sleep(1)  
  31.   
  32. threadList = ["Thread-1", "Thread-2", "Thread-3"]  
  33. nameList = ["One", "Two", "Three", "Four", "Five"]  
  34. queueLock = threading.Lock()  
  35. workQueue = Queue.Queue(10)  
  36. threads = []  
  37. threadID = 1  
  38.   
  39. # 创建新线程  
  40. for tName in threadList:  
  41.     thread = myThread(threadID, tName, workQueue)  
  42.     thread.start()  
  43.     threads.append(thread)  
  44.     threadID += 1  
  45.   
  46. # 填充队列  
  47. queueLock.acquire()  
  48. for word in nameList:  
  49.     workQueue.put(word)  
  50. queueLock.release()  
  51.   
  52. # 等待队列清空  
  53. while not workQueue.empty():  
  54.     pass  
  55.   
  56. # 通知线程是时候退出  
  57. exitFlag = 1  
  58.   
  59. # 等待所有线程完成  
  60. for t in threads:  
  61.     t.join()  
  62. print "Exiting Main Thread"  
» 转载请注明来源:若我若鱼 » Python 系列(15) 多线程

Leave a Reply

Your email address will not be published. Required fields are marked *

one × 2 =