我们将会看到一些在Python中使用线程的实例和如何避免线程之间的竞争。你应当将下边的例子运行多次,以便可以注意到线程是不可预测的和线程每次运行出的不同结果。声明:从这里开始忘掉你听到过的关于GIL的东西,因为GIL不会影响到我想要展示的东西。
示例1
我们将要请求五个不同的url:
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
        
      
        7 
        
      
        8 
        
      
        9 
        
      
        10 
        
      
        11 
        
      
        12 
        
      
        13 
        
      
        14 
        
      
        15 
        
      
        16 
        
      
        17 
        
      
        18 
        
      
        19 
         |  
      
       
         importtime 
         
       
         importurllib2 
         
       
         defget_responses(): 
         
       
             urls=[ 
         
       
                 ‘http://www.google.com‘, 
         
       
                 ‘http://www.amazon.com‘, 
         
       
                 ‘http://www.ebay.com‘, 
         
       
                 ‘http://www.alibaba.com‘, 
         
       
                 ‘http://www.reddit.com‘ 
         
       
             ] 
         
       
             start=time.time() 
         
       
             forurlinurls: 
         
       
                 printurl 
         
       
                 resp=urllib2.urlopen(url) 
         
       
                 printresp.getcode() 
         
       
             print"Elapsed time: %s"%(time.time()-start) 
         
       
         get_responses() 
         
       |  
    
输出是:
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
         |  
      
       
         http://www.google.com200 
         
       
         http://www.amazon.com200 
         
       
         http://www.ebay.com200 
         
       
         http://www.alibaba.com200 
         
       
         http://www.reddit.com200 
         
       
         Elapsed time:3.0814409256 
         
       |  
    
解释:
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
        
      
        7 
        
      
        8 
        
      
        9 
        
      
        10 
        
      
        11 
        
      
        12 
        
      
        13 
        
      
        14 
        
      
        15 
        
      
        16 
        
      
        17 
        
      
        18 
        
      
        19 
        
      
        20 
        
      
        21 
        
      
        22 
        
      
        23 
        
      
        24 
        
      
        25 
        
      
        26 
        
      
        27 
        
      
        28 
        
      
        29 
        
      
        30 
        
      
        31 
        
      
        32 
         |  
      
       
         importurllib2 
         
       
         importtime 
         
       
         fromthreadingimportThread 
         
       
         classGetUrlThread(Thread): 
         
       
             def__init__(self, url): 
         
       
                 self.url=url 
         
       
                 super(GetUrlThread,self).__init__() 
         
       
             defrun(self): 
         
       
                 resp=urllib2.urlopen(self.url) 
         
       
                 printself.url, resp.getcode() 
         
       
         defget_responses(): 
         
       
             urls=[ 
         
       
                 ‘http://www.google.com‘, 
         
       
                 ‘http://www.amazon.com‘, 
         
       
                 ‘http://www.ebay.com‘, 
         
       
                 ‘http://www.alibaba.com‘, 
         
       
                 ‘http://www.reddit.com‘ 
         
       
             ] 
         
       
             start=time.time() 
         
       
             threads=[] 
         
       
             forurlinurls: 
         
       
                 t=GetUrlThread(url) 
         
       
                 threads.append(t) 
         
       
                 t.start() 
         
       
             fortinthreads: 
         
       
                 t.join() 
         
       
             print"Elapsed time: %s"%(time.time()-start) 
         
       
         get_responses() 
         
       |  
    
输出:
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
         |  
      
       
         http://www.reddit.com200 
         
       
         http://www.google.com200 
         
       
         http://www.amazon.com200 
         
       
         http://www.alibaba.com200 
         
       
         http://www.ebay.com200 
         
       
         Elapsed time:0.689890861511 
         
       |  
    
解释:
关于线程:
我们将会用一个程序演示一下多线程间的资源竞争,并修复这个问题。
多次运行这个程序,你会看到多种不同的结果。
解释:
为什么没有达到50?
解决资源竞争
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
        
      
        7 
        
      
        8 
        
      
        9 
        
      
        10 
        
      
        11 
        
      
        12 
        
      
        13 
        
      
        14 
        
      
        15 
        
      
        16 
        
      
        17 
        
      
        18 
        
      
        19 
        
      
        20 
        
      
        21 
        
      
        22 
        
      
        23 
        
      
        24 
        
      
        25 
        
      
        26 
        
      
        27 
        
      
        28 
         |  
      
       
         fromthreadingimportLock, Thread 
         
       
         lock=Lock() 
         
       
         some_var=0 
         
       
         classIncrementThread(Thread): 
         
       
             defrun(self): 
         
       
                 #we want to read a global variable 
         
       
                 #and then increment it 
         
       
                 globalsome_var 
         
       
                 lock.acquire() 
         
       
                 read_value=some_var 
         
       
                 print"some_var in %s is %d"%(self.name, read_value) 
         
       
                 some_var=read_value+1 
         
       
                 print"some_var in %s after increment is %d"%(self.name, some_var) 
         
       
                 lock.release() 
         
       
         defuse_increment_thread(): 
         
       
             threads=[] 
         
       
             foriinrange(50): 
         
       
                 t=IncrementThread() 
         
       
                 threads.append(t) 
         
       
                 t.start() 
         
       
             fortinthreads: 
         
       
                 t.join() 
         
       
             print"After 50 modifications, some_var should have become 50" 
         
       
             print"After 50 modifications, some_var is %d"%(some_var,) 
         
       
         use_increment_thread() 
         
       |  
    
再次运行这个程序,达到了我们预期的结果。
解释:
让我们用一个例子来证明一个线程不能影响其他线程内的变量(非全局变量)。
time.sleep()可以使一个线程挂起,强制线程切换发生。
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
        
      
        7 
        
      
        8 
        
      
        9 
        
      
        10 
        
      
        11 
        
      
        12 
        
      
        13 
        
      
        14 
        
      
        15 
        
      
        16 
        
      
        17 
         |  
      
       
         fromthreadingimportThread 
         
       
         importtime 
         
       
         classCreateListThread(Thread): 
         
       
             defrun(self): 
         
       
                 self.entries=[] 
         
       
                 foriinrange(10): 
         
       
                     time.sleep(1) 
         
       
                     self.entries.append(i) 
         
       
                 printself.entries 
         
       
         defuse_create_list_thread(): 
         
       
             foriinrange(3): 
         
       
                 t=CreateListThread() 
         
       
                 t.start() 
         
       
         use_create_list_thread() 
         
       |  
    
运行几次后发现并没有打印出争取的结果。当一个线程正在打印的时候,cpu切换到了另一个线程,所以产生了不正确的结果。我们需要确保print self.entries是个逻辑上的原子操作,以防打印时被其他线程打断。
我们使用了Lock(),来看下边的例子。
|  
       
        1 
        
      
        2 
        
      
        3 
        
      
        4 
        
      
        5 
        
      
        6 
        
      
        7 
        
      
        8 
        
      
        9 
        
      
        10 
        
      
        11 
        
      
        12 
        
      
        13 
        
      
        14 
        
      
        15 
        
      
        16 
        
      
        17 
        
      
        18 
        
      
        19 
        
      
        20 
        
      
        21 
         |  
      
       
         fromthreadingimportThread, Lock 
         
       
         importtime 
         
       
         lock=Lock() 
         
       
         classCreateListThread(Thread): 
         
       
             defrun(self): 
         
       
                 self.entries=[] 
         
       
                 foriinrange(10): 
         
       
                     time.sleep(1) 
         
       
                     self.entries.append(i) 
         
       
                 lock.acquire() 
         
       
                 printself.entries 
         
       
                 lock.release() 
         
       
         defuse_create_list_thread(): 
         
       
             foriinrange(3): 
         
       
                 t=CreateListThread() 
         
       
                 t.start() 
         
       
         use_create_list_thread() 
         
       |  
    
这次我们看到了正确的结果。证明了一个线程不可以修改其他线程内部的变量(非全局变量)。
原文:http://my.oschina.net/u/162418/blog/341777