关于Python的线程

       我们在做软件开发的时候很多要用到多线程技术。例如如果做一个下载软件象flashget就要用到、象在线视频工具realplayer也要用到因为要同时下载media stream还要播放。其实例子是很多的。
         线程相对进程来说是“轻量级”的，操作系统用较少的资源创建和管理线程。程序中的线程在相同的内存空间中执行，并共享许多相同的资源。
在python中如何创建一个线程对象：
         如果你要创建一个线程对象，很简单，只要你的类继承threading.Thread，然后在__init__里首先调用threading.Thread的__init__方法即可：
import threading
class mythread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name = threadname)
....
         这才仅仅是个空线程，我可不是要他拉空车的，他可得给我干点实在活。很简单，重写类的run()方法即可，把你要在线程执行时做的事情都放到里面
import threading
import time
class mythread(threading.Thread):
def __init__(...):
....
def run(self):
for i in range(10):
print self.getName, i
time.sleep(1)
         以上代码我们让这个线程在执行之后每隔1秒输出一次信息到屏幕，10次后结束getName()是threading.Thread类的一个方法，用来获得这个线程对象的name。还有一个方法setName()当然就是来设置这个线程对象的name的了。
         如果要创建一个线程，首先就要先创建一个线程对象
mythread1 = mythread('mythread 1')
         一个线程对象被创建后，他就处于“born”（诞生状态），如何让这个线程对象开始运行呢？只要调用线程对象的start()方法即可：
mythread1.start()
现在线程就处于“ready”状态或者也称为“runnable”状态。
         奇怪吗？不是已经start了吗？为什么不称为“running”状态呢？其实是有原因的。因为我们的计算机一般是不具有真正并行处理能力的。我们所谓的多线程只是把时间分成片段，然后隔一个时间段就让一个线程执行一下，然后进入“sleeping ”状态，然后唤醒另一个在“sleeping”的线程，如此循环runnable->sleeping->runnable... ，只是因为计算机执行速度很快，而时间片段间隔很小，我们感受不到，以为是同时进行的。所以说一个线程在start了之后只是处在了可以运行的状态，他什么时候运行还是由系统来进行调度的。
         那一个线程什么时候会“dead”呢？一般来说当线程对象的run方法执行结束或者在执行中抛出异常的话，那么这个线程就会结束了。系统会自动对“dead”状态线程进行清理。
         如果一个线程t1在执行的过程中需要等待另一个线程t2执行结束后才能运行的话那就可以在t1在调用t2的join()方法
....
def t1(...):
...
t2.join()
...
这样t1在执行到t2.join()语句后就会等待t2结束后才会继续运行。
         但是假如t1是个死循环的话那么等待就没有意义了，那怎么办呢？可以在调用t2的join()方法的时候给一个浮点数做超时参数，这样这个线程就不会等到花儿也谢了了。我等你10s，你不回来我还不允许我改嫁啊？:)
def t1(...):
...
t2.join(10)
...
         如果一个进程的主线程运行完毕而子线程还在执行的话，那么进程就不会退出，直到所有子线程结束为止，如何让主线程结束的时候其他子线程也乖乖的跟老大撤退呢？那就要把那些不听话的人设置为听话的小弟，使用线程对象的setDaemon()方法，参数为bool型。True的话就代表你要听话，我老大（主线程）扯呼，你也要跟着撤，不能拖后腿。如果是False的话就不用那么听话了，老大允许你们将在外军命有所不受的。需要注意的是setDaemon()方法必须在线程对象没有调用start()方法之前调用，否则没效果。
t1 = mythread('t1')
print t1.getName(),t1.isDaemon()
t1.setDaemon(True)
print t1.getName(),t1.isDaemon()
t1.start()
print 'main thread exit'
         当执行到 print 'main thread exit' 后，主线程就退出了，当然t1这个线程也跟着结束了。但是如果不使用t1线程对象的setDaemon()方法的话，即便主线程结束了，还要等待t1线程自己结束才能退出进程。isDaemon()是用来获得一个线程对象的Daemonflag状态的。
         如何来获得与线程有关的信息呢？
获得当前正在运行的线程的引用：
running = threading.currentThread()
获得当前所有活动对象（即run方法开始但是未终止的任何线程）的一个列表：
threadlist = threading.enumerate()
获得这个列表的长度：
threadcount = threading.activeCount()
查看一个线程对象的状态调用这个线程对象的isAlive()方法，返回1代表处于“runnable”状态且没有“dead”：
threadflag = threading.isAlive()

 

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

        1、调用thread模块中的start_new_thread()函数来产生新的线程，请看代码:

    ### thread_example.py
     import time
     import thread     

    def timer(no,interval): #自己写的线程函数
         while True:
             print 'Thread :(%d) Time:%s'%(no,time.ctime())
             time.sleep(interval)
     def test():#使用thread.start_new_thread()来产生2个新的线程
         thread.start_new_thread(timer,(1,1)) 
         thread.start_new_thread(timer,(2,3))
     if__name__=='__main__':
        test()

这个是 thread.start_new_thread(function,args[,kwargs]) 函数原型，其中function参数是你将要调用的线程函数；args是讲传递给你的线程函数的参数，他必须是个tuple类型；而kwargs是可选的参数。线程的结束一般依靠线程函数的自然结束；也可以在线程函数中调用thread.exit()，他抛出SystemExit exception，达到退出线程的目的。

      2、通过调用threading模块继承threading.Thread类来包装一个线程对象。请看代码
            ### threading_example.py
      import threading
      import time
 
     # 我的timer类继承自threading.Thread类
     class timer(threading.Thread):   
         # 在我重写__init__方法的时候要记得调用基类的__init__方法
         def __init__(self, no, interval): 
             threading.Thread.__init__(self)
             self.no = no
             self.interval = interval 

        # 重写run()方法，把自己的线程函数的代码放到这里
         def run(self):                     
             while True:
             print 'Thread Object (%d), Time:%s'%(self.no, time.ctime())
             time.sleep(self.interval)    

     def test():
         # 产生2个线程对象
         threadone = timer(1, 1)
         threadtwo = timer(2, 3)
  
         # 通过调用线程对象的.start()方法来激活线程
         threadone.start()               
         threadtwo.start()
 
     # main test
     if name__=='__main__':
          test()

其实thread和threading的模块中还包含了其他的很多关于多线程编程的东西，例如锁、定时器、获得激活线程列表等等，请大家仔细参考python的文档！另外，线程还有退出的问题，这可以有很多种解决方法， 如事件，信号通知等。

下面是一个带事件的线程：

####
import sys
import time
import thread
import threading

e1 = threading.Event()
e2 = threading.Event()

def timer1(no, interval):
    exit_count = 0
    while True:
        print 'Thread:(%d) Time:%s' % (no, time.ctime())
        time.sleep(interval)
        exit_count = exit_count + 1
        if exit_count == 10:
            e1.set()
            break
    print 'end thread -- %d' %( no, )

def timer2(no, interval):
    while True:
        print 'Thread:(%d) Time:%s' % (no, time.ctime())
        time.sleep(interval)
        if e1.isSet():
            e2.set()
            break
    print 'end thread -- %d' % ( no, )
       

def test():   
    thread.start_new_thread(timer1, (1, 1))
    thread.start_new_thread(timer2, (2, 3))

    ## 
    e1.wait()
    e2.wait()

    print('End test.')

#
if __name__ == '__main__':
    test()