Python多线程基础

来源：互联网发布：js计算时间差天数编辑：程序博客网时间：2024/05/19 21:00

http://www.17jo.com/program/python/app/ThreadUse.html

1. Python多线程基础

Python多线程编程，当程序需要同时并发处理多个任务时，就需要要使用多线程编程。

继承线程类threading.thread，再重载成员函数run，程序处理的代码写在函数run中，最后再调用start()方法来运行线程，而join()方法可以用来等待线程结束。

多线程的资源同步，可使用thread.RLock()来创建资源锁，然后使用acquire()来锁住资源，release()来释放资源。等待事件用thread.Event()，用wait()来等待事件，set()来激发事件，clear()用于清除已激发事件。

另外可以用isAlive()来判断线程是否存活着。

# 例：多线程编程

[cpp] view plaincopy
#!/usr/bin/env python  
#threads1.py  
import time                 # 导入时间模块  
import threading as thread  # 导入线程模块  
class Thread1(thread.Thread):  
    def __init__(self):  
        thread.Thread.__init__(self)    # 默认初始化  
        self.lock = thread.RLock()      # 创建资源锁  
        self.flag = True  
        self.count = 0  
    def run(self):  
        print 'Thread1 run'  
        while self.count < 3:  
            self.lock.acquire()         # 锁住资源  
            self.count += 1  
            print self.count            # 输出计数  
            self.lock.release()         # 释放资源  
            time.sleep(1)               # 线程休眠1秒  
        print 'Thread1 end'  
          
class Thread2(thread.Thread):  
    def __init__(self,event):  
        thread.Thread.__init__(self)    # 初始化线程  
        self.event = event  
    def run(self):  
        self.event.wait()               # 线程启动后等待事件  
        print 'Thread2 run'  
        self.event.clear()              # 清除事件  
        print 'Thread2 end'  
print 'program start'  
event = thread.Event()  
t1 = Thread1()  
t2 = Thread2(event)  
t1.start()              # 线程t1启动  
t2.start()              # 线程t2启动  
t1.join()               # 等待线程t1结束  
event.set()             # 激发事件t2开始运行   
t2.join()               # 等待线程t2结束  
print 'program end'     # 结束程序  
>> program start   # 输出  
>> Thread1 run  
>> 1  
>> 2  
>> 3  
>> Thread1 end  
>> Thread2 run  
>> Thread2 end  
>> program end  

2. Python多线程编程的两种方式

http://guanjh.iteye.com/blog/88904

Python中如果要使用线程的话，python的lib中提供了两种方式。一种是函数式，一种是用类来包装的线程对象。举两个简单的例子希望起到抛砖引玉的作用，关于多线程编程的其他知识例如互斥、信号量、临界区等请参考python的文档及相关资料。

1.调用thread模块中的start_new_thread()函数来产生新的线程

请看代码：

[cpp] view plaincopy
#!/usr/bin/env python  
#thread_example1.py  
import time  
import _thread  
def timer(no,interval):  
    print('timer Begin:')  
    while True:  
        print('Thread :(%d) Time:%s'%(no,time.ctime()))  
        time.sleep(interval)  
          
def test():  
    print('Test Begin:')  
    _thread.start_new_thread(timer,(1,1))  
    _thread.start_new_thread(timer,(2,3))  
  
print(__name__)  
if __name__=='__main__':  
    test()  
    time.sleep(20)  # 注意这里, 必须这样子, 因为如果不睡眠  
                    # test()之后程序就直接退出了, 线程都没有来得及运行  

这个是thread.start_new_thread(function,args[,kwargs])函数原型，其中function参数是你将要调用的线程函数；args是讲传递给你的线程函数的参数，他必须是个tuple类型；而kwargs是可选的参数。

线程的结束一般依靠线程函数的自然结束；也可以在线程函数中调用thread.exit()，他抛出SystemExit exception，达到退出线程的目的。

2. 通过调用threading模块继承threading.Thread类来包装一个线程对象。

请看代码：

[cpp] view plaincopy
#!/usr/bin/env python  
#thread_example2.py  
import threading  
import time  
class timer(threading.Thread):      #我的timer类继承自threading.Thread类     
    def __init__(self,no,interval):      
        #在我重写__init__方法的时候要记得调用基类的__init__方法     
        threading.Thread.__init__(self)          
        self.no=no     
        self.interval=interval     
   
    def run(self):  #重写run()方法，把自己的线程函数的代码放到这里  
        i = 4  
        while i > 0:  
            print(i)  
            print('Thread Object (%d), Time:%s'%(self.no,time.ctime()))  
            time.sleep(self.interval)  
            i = i - 1  
  
def test():     
    threadone=timer(1,1)    #产生2个线程对象     
    threadtwo=timer(2,3)     
    threadone.start()   #通过调用线程对象的.start()方法来激活线程     
    threadtwo.start()     
         
if __name__=='__main__':     
    test()    

其实thread和threading的模块中还包含了其他的很多关于多线程编程的东西，例如锁、定时器、获得激活线程列表等等，请大家仔细参考python的文档！

3. 我自己的习惯

我在使用C++时的多线程, 我更喜欢用线程函数的结束来代表线程的结束, 这样对于某些资源的释放情况更容易掌握一些