Python高级编程之多线程
Python 多线程
多线程类似于同时执行多个不同程序，多线程运行有如下优点：
- 使用线程可以把占据长时间的程序中的任务放到后台去处理。
- 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
- 程序的运行速度可能加快
- 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
- 线程可以被抢占（中断）。
- 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。
开始学习Python线程
Python中使用线程有两种方式：函数或者用类来包装线程对象。
函数式：调用thread模块中的start_new_thread()函数来产生新线程。语法如下:
thread.start_new_thread ( function, args[, kwargs] )
参数说明:
- function - 线程函数。
- args - 传递给线程函数的参数,他必须是个tuple类型。
- kwargs - 可选参数。
实例1：
#coding=utf-8
#!/usr/bin/python
#解决UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe5 in position 108: ordinal not in range(128)
import sys
reload(sys)
sys.setdefaultencoding('utf8')
import ipython_debug
import thread
import time
def print_time(threadName,delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
currentTime = time.ctime(time.time())
print "线程名:%s,当前时间:%s" % (threadName,currentTime)
#创建两个线程,分别每隔2秒或4秒打印一下当前时间
try:
thread.start_new_thread(print_time,("IM_Thread_1",2,))
thread.start_new_thread(print_time,("IM_Thread_2",4))
except Exception, e:
print "error:",e;
#故意阻塞主线程
while 1:
pass
运行结果如下:
线程的结束一般依靠线程函数的自然结束；也可以在线程函数中调用thread.exit()，他抛出SystemExit exception，达到退出线程的目的。
线程模块
Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。
thread 模块提供的其他方法：
- threading.currentThread(): 返回当前的线程变量。
- threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行 是指 线程启动后、结束前，不包括启动前和终止后的线程。
- threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。???Excuse Me???
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。
使用Threading模块创建线程
使用Threading模块创建线程，直接从threading.Thread继承，然后重写父类的__init__方法和run方法
实例2代码如下:
#coding=utf-8
#!/usr/bin/python
#解决UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe5 in position 108: ordinal not in range(128)
import sys
reload(sys)
sys.setdefaultencoding('utf8')
import ipython_debug
import threading
import time
#自定义线程类继承自系统的threading模块的Thread类
class BeyondThread(threading.Thread):
def __init__(self, threadID, threadName,time_delay):
#显式执行父类的构造方法
threading.Thread.__init__(self)
self.threadID = threadID
self.threadName = threadName
#这个是什么鬼,打印的时间间隔
self.time_delay = time_delay
#重写run方法
def run(self):
print "--->"+self.threadName
#打印次数
printTimes = 5
print_currentTime(self.threadName,self.time_delay,printTimes)
print "<---"+self.threadName
def print_currentTime(threadName,time_delay,printTimes):
while printTimes:
#睡觉
time.sleep(time_delay)
print "线程名:%s,当前时间:%s" % (threadName,time.ctime(time.time()))
printTimes -= 1
#创建线程子类(第1个是线程ID,第3个参数是什么鬼)
thread_1 = BeyondThread(1,"1_Thread",1)
thread_2 = BeyondThread(2,"2_Thread",4)
thread_1.start()#线程开启
thread_2.start()#线程开启
运行结果如下:
线程同步
如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法，对于那些每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。如下：
多线程的优势在于可以同时运行多个任务（至少感觉起来是这样,但是由于在python的原始解释器CPython中存在着GIL即Global Interpreter Lock，全局解释器锁,所以...）。但是当线程需要共享数据时，可能存在数据不同步的问题。
考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。
锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
实例3代码如下：
#coding=utf-8
#!/usr/bin/python
#解决UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe5 in position 108: ordinal not in range(128)
import sys
reload(sys)
sys.setdefaultencoding('utf8')
import ipython_debug
import threading
import time
#自定义线程类继承自系统的threading模块的Thread类
class BeyondThread(threading.Thread):
def __init__(self, threadID, threadName,time_delay):
#显式执行父类的构造方法
threading.Thread.__init__(self)
self.threadID = threadID
self.threadName = threadName
#这个是什么鬼,打印的时间间隔
self.time_delay = time_delay
#重写run方法
def run(self):
print "--->"+self.threadName
#打印次数
#核心加锁代码
beyondThreadLock.acquire()
printTimes = 5
print_currentTime(self.threadName,self.time_delay,printTimes)
#释放锁
beyondThreadLock.release()
print "<---"+self.threadName
def print_currentTime(threadName,time_delay,printTimes):
while printTimes:
#睡觉
time.sleep(time_delay)
print "线程名:%s,当前时间:%s" % (threadName,time.ctime(time.time()))
printTimes -= 1
#创建锁
beyondThreadLock = threading.Lock()
#用于join(连接)的线程列表
beyondThreadList = []
#创建线程子类(第1个是线程ID,第3个参数是什么鬼)
thread_1 = BeyondThread(1,"1_Thread",1)
thread_2 = BeyondThread(2,"2_Thread",4)
thread_1.start()#线程开启
thread_2.start()#线程开启
#将线程添加到线程列表中,以便于遍历并join
beyondThreadList.append(thread_1)
beyondThreadList.append(thread_2)
#join什么鬼???
for tmpThread in beyondThreadList:
tmpThread.join()
print "Main Thread Exit"
运行结果如下:
线程优先级队列（ 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() 实际上意味着等到队列为空，再执行别的操作
实例4代码如下:
#coding=utf-8
#!/usr/bin/python
#解决UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe5 in position 108: ordinal not in range(128)
import sys
reload(sys)
sys.setdefaultencoding('utf8')
import ipython_debug
import threading
import time
import Queue
#手动退出的标记
exitFlag = 0
#自定义的线程继承自:threading.Thread
class BeyondThread(threading.Thread):
#参数2是自定义队列
def __init__(self,threadID,threadName, elementQueue):
threading.Thread.__init__(self)
self.threadID = threadID
self.threadName = threadName
self.elementQueue = elementQueue
#重写run方法
def run(self):
print "线程开始操作队列--->"+self.threadName
multiThreadPrintElementsInQueue(self.threadName,self.elementQueue)
print "线程操作完成<---"+self.threadName
#???使用多个线程去按顺序打印出队列里的元素
def multiThreadPrintElementsInQueue(threadName,elementQueue):
#
while exitFlag != 1:
#加锁---->
beyondThreadLock.acquire()
#如果队列里有元素,就取出元素打印
if elementQueue.empty() != True:
#从元素队列里取出一个元素(此时队列里的元素就会少一个了)
element = elementQueue.get()
#解锁
beyondThreadLock.release()
print "线程:%s 取出队列的元素:%s进行打印" % (threadName,element)
#队列里的元素已经全部取完了,已经没有元素的时候,也要解锁
else:
beyondThreadLock.release()
#???睡觉是个什么鬼
time.sleep(3)
threadNameList = ["1_thread","2_thread","3_thread"]
elementList = ["1.k-on","2.龙与虎","3.未闻花名","4.石头门","5.钢炼"]
beyondThreadLock = threading.Lock()
#??? 10 是个什么鬼
elementQueue = Queue.Queue(10)
beyondThreadList = []
tempThreadID = 1
#创建N个线程,并启动
print "sg__before thread create and start"
for tmpThreadName in threadNameList:
#有多少个线程名字,就创建多少个线程
tmpThread = BeyondThread(tempThreadID,tmpThreadName,elementQueue)
#启动线程
tmpThread.start()
#加入到线程列表
beyondThreadList.append(tmpThread)
tempThreadID += 1
print "sg__after thread create and start"
#加锁,并为队列填充数据
beyondThreadLock.acquire()
print "sg__before put queue"
for movieName in elementList:
elementQueue.put(movieName)
print "sg__after put queue"
beyondThreadLock.release()
print "sg__before while"
#???等待队列清空???执行顺序
while elementQueue.empty() != True:
pass
#执行到这儿,说明元素已经全部被get()出来了,队列已空,所以可以让线程的run()方法中的while循环结束了
exitFlag = 1
print "sg__after while"
print "sg__before join"
#???join是个什么鬼
#线程A 可以调用线程B 的 join() 方法，调用后线程A 会被挂起，直到线程B 结束
#这儿的作用是先把各个线程加入主线程里并阻塞主线程,同时由于exitFlag已经设立,所以各线程肯定会结束,然后返回到主线程中向下继续执行
for tmpThread in beyondThreadList:
tmpThread.join()
print "sg__after join"
print "Main Thread Exit"
运行结果如下:
扫一扫
6440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
