Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1273317
  • 博文数量: 164
  • 博客积分: 2993
  • 博客等级: 少校
  • 技术积分: 1718
  • 用 户 组: 普通用户
  • 注册时间: 2011-06-24 11:42
文章分类

全部博文(164)

文章存档

2014年(1)

2013年(36)

2012年(90)

2011年(37)

分类: Python/Ruby

2011-09-28 13:53:51

基础不必多讲,还是直接进入python。

    Python代码代码的执行由python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中,同时只有一个线程在执行,就像单CPU的系统中运行多个进程那样,内存中可以存放多个程序,但任意时候,只有一个程序在CPU中运行。同样,虽然python解释器可以“运行”多个线程,但在任意时刻,只有一个线程在解释器中运行。

 

    对python虚拟机的访问由全局解释器锁(GIL)来控制,这个GIL能保证同一时刻只有一个线程在运行。在多线程环境中,python虚拟机按以下方式执行:

   1 设置GIL

   2 切换到一个线程去运行

   3 运行:(a.指定数量的字节码指令,或者b.线程主动让出控制(可以调用time.sleep()))

   4 把线程设置为睡眠状态

   5 解锁GIL

   6 重复以上所有步骤

 

   那么为什么要提出多线程呢?我们首先看一个单线程的例子。

 

from time import sleep,ctime

 

def loop0():

    print 'start loop 0 at:',ctime()

    sleep(4)

    print 'loop 0 done at:',ctime()

 

def loop1():

    print 'start loop 1 at:',ctime()

    sleep(2)

    print 'loop 1 done at:',ctime()

 

def main():

    print 'starting at:',ctime()

    loop0()

    loop1()

    print 'all DONE at:',ctime()

 

if __name__=='__main__':

    main()

 

运行结果:

>>>

starting at: Mon Aug 31 10:27:23 2009

start loop 0 at: Mon Aug 31 10:27:23 2009

loop 0 done at: Mon Aug 31 10:27:27 2009

start loop 1 at: Mon Aug 31 10:27:27 2009

loop 1 done at: Mon Aug 31 10:27:29 2009

all DONE at: Mon Aug 31 10:27:29 2009

>>>

 

可以看到单线程中的两个循环, 只有一个循环结束后另一个才开始。  总共用了6秒多的时间。假设两个loop中执行的不是sleep,而是一个别的运算的话,如果我们能让这些运算并行执行的话,是不是可以减少总的运行时间呢,这就是我们提出多线程的前提。

 

 

Python中的多线程模块:thread,threading,Queue。

 

1  thread ,这个模块一般不建议使用。下面我们直接把以上的例子改一下,演示一下。

from time import sleep,ctime

import thread

 

def loop0():

    print 'start loop 0 at:',ctime()

    sleep(4)

    print 'loop 0 done at:',ctime()

 

def loop1():

    print 'start loop 1 at:',ctime()

    sleep(2)

    print 'loop 1 done at:',ctime()

 

def main():

    print 'starting at:',ctime()

    thread.start_new_thread(loop0,())

    thread.start_new_thread(loop1,())

    sleep(6)

    print 'all DONE at:',ctime()

 

if __name__=='__main__':

    main()

   

运行结果:

>>>

starting at: Mon Aug 31 11:04:39 2009

start loop 0 at: Mon Aug 31 11:04:39 2009

start loop 1 at: Mon Aug 31 11:04:39 2009

loop 1 done at: Mon Aug 31 11:04:41 2009

loop 0 done at: Mon Aug 31 11:04:43 2009

all DONE at: Mon Aug 31 11:04:45 2009

>>> 

可以看到实际是运行了4秒两个loop就完成了。效率确实提高了。

 

2 threading模块

   首先看一下threading模块中的对象:

   Thread    :表示一个线程的执行的对象

   Lock     :锁原语对象

   RLock    :可重入锁对象。使单线程可以再次获得已经获得的锁

   Condition  :条件变量对象能让一个线程停下来,等待其他线程满足了某个“条件”,如状态的改变或值的改变

   Event     :通用的条件变量。多个线程可以等待某个事件发生,在事件发生后,所有的线程都被激活

  Semaphore  :为等待锁的线程提供一个类似“等候室”的结构

  BoundedSemaphore  :与semaphore类似,只是它不允许超过初始值

  Timer       :  与Thread类似,只是,它要等待一段时间后才开始运行

 

 

 其中Thread类是你主要的运行对象,它有很多函数,用它你可以用多种方法来创建线程,常用的为以下三种。

 创建一个Thread的实例,传给它一个函数

 创建一个Thread实例,传给它一个可调用的类对象

 从Thread派生出一个子类,创建一个这个子类的实例

 

 Thread类的函数有:

       getName(self)  返回线程的名字

     | 

     |  isAlive(self)  布尔标志,表示这个线程是否还在运行中

     | 

     |  isDaemon(self)  返回线程的daemon标志

     | 

     |  join(self, timeout=None) 程序挂起,直到线程结束,如果给出timeout,则最多阻塞timeout秒

     | 

     |  run(self)  定义线程的功能函数

     | 

     |  setDaemon(self, daemonic)  把线程的daemon标志设为daemonic

     | 

     |  setName(self, name)  设置线程的名字

     | 

     |  start(self)   开始线程执行

 

   下面看一个例子:(方法一:创建Thread实例,传递一个函数给它)
import threading

from time import sleep,ctime

 

loops=[4,2]

 

def loop(nloop,nsec):

       print 'start loop',nloop,'at:',ctime()

       sleep(nsec)

       print 'loop',nloop,'done at:',ctime()

def main():

       print 'starting at:',ctime()

       threads=[]

       nloops=range(len(loops))

       for i in nloops:

              t=threading.Thread(target=loop,args=(i,loops[i]))

              threads.append(t)

       for i in nloops:

              threads[i].start()

       for i in nloops:

              threads[i].join()

             

       print 'all done at:',ctime()

      

if __name__=='__main__':

       main()

    可以看到第一个for循环,我们创建了两个线程,这里用到的是给Thread类传递了函数,把两个线程保存到threads列表中,第二个for循环是让两个线程开始执行。然后再让每个线程分别调用join函数,使程序挂起,直至两个线程结束。

 

另外的例子:(方法二:创建一个实例,传递一个可调用的类的对象)

 

import threading

from time import sleep,ctime

 

loops=[4,2]

 

class ThreadFunc(object):

       def __init__(self,func,args,name=''):

              self.name=name

              self.func=func

              self.args=args

       def __call__(self):

              self.res=self.func(*self.args)

def loop(nloop,nsec):

       print 'start loop',nloop,'at:',ctime()

       sleep(nsec)

       print 'loop',nloop,'done at:',ctime()

def main():

       print 'starting at:',ctime()

       threads=[]

       nloops=range(len(loops))

       for i in nloops:

              t=threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))

              threads.append(t)

       for i in nloops:

              threads[i].start()

       for i in nloops:

              threads[i].join()

       print 'all done at:',ctime()

 

if __name__=='__main__':

       main()

 

 

最后的方法:(方法三:创建一个这个子类的实例)

import threading

from time import sleep,ctime

 

loops=(4,2)

 

class MyThread(threading.Thread):

       def __init__(self,func,args,name=''):

              threading.Thread.__init__(self)

              self.name=name

              self.func=func

              self.args=args

       def run(self):

              apply(self.func,self.args)

def loop(nloop,nsec):

       print 'start loop',nloop,'at:',ctime()

       sleep(nsec)

       print 'loop',nloop,'done at:',ctime()

      

def main():

       print 'starting at:',ctime()

       threads=[]

       nloops=range(len(loops))

      

       for i in nloops:

              t=MyThread(loop,(i,loops[i]),loop.__name__)

              threads.append(t)

       for i in nloops:

              threads[i].start()

      

       for i in nloops:

              threads[i].join()

             

       print 'all done at:',ctime()

if __name__=='__main__':

       main()

 

另外我们可以把MyThread单独编成一个脚本模块,然后我们可以在别的程序里导入这个模块直接使用。

阅读(2263) | 评论(0) | 转发(0) |
0

上一篇:Python socket编程(UDP)

下一篇:python线程同步

给主人留下些什么吧!~~