threading.local()

当我们使用线程的时候，能使用线程的局部变量，就尽量不要用全局变量，因为使用全局变量涉及同步的问题（参见我的上一篇博客Python学习总结笔记（3）–多线程与线程同步 ）。

使用局部变量的时候，需要传递参数，比如有这样一个例子，程序需要处理客户申请，每来一个客户，就新开一个线程进行处理，而客户有姓名、年龄、性别等属性（参数），如果都需要传递参数的话很繁琐。Python提供了threading.local模块，方便我们实现线程局部变量的传递。直接看下面的例子:

# /usr/bin/env python
# coding:utf-8

__author__ = 'kikay'

import threading

# Threading.local对象
ThreadLocalHelper = threading.local()
lock = threading.RLock()

class MyTheadEx(threading.Thread):
    def __init__(self, threadName, name, age, sex):
        super(MyTheadEx, self).__init__(name=threadName)
        self.__name = name
        self.__age = age
        self.__sex = sex

    def run(self):
        global ThreadLocalHelper
        ThreadLocalHelper.ThreadName = self.name
        ThreadLocalHelper.Name = self.__name
        ThreadLocalHelper.Age = self.__age
        ThreadLocalHelper.Sex = self.__sex
        MyTheadEx.ThreadPoc()

    # 线程处理函数
    @staticmethod
    def ThreadPoc():
        lock.acquire()
        try:
            print 'Thread={id}'.format(id=ThreadLocalHelper.ThreadName)
            print 'Name={name}'.format(name=ThreadLocalHelper.Name)
            print 'Age={age}'.format(age=ThreadLocalHelper.Age)
            print 'Sex={sex}'.format(sex=ThreadLocalHelper.Sex)
            print '----------'
        finally:
            lock.release()

if __name__ == '__main__':
    Tom = {'Name': 'tom', 'Age': 20, 'Sex': 'man'}
    xiaohua = {'Name': 'xiaohua', 'Age': 18, 'Sex': 'woman'}
    Andy = {'Name': 'Andy', 'Age': 40, 'Sex': 'man'}
    T = (Tom, xiaohua, Andy)
    threads = []
    for i in range(len(T)):
        t = MyTheadEx(threadName='id_{0}'.format(i), name=T[i]['Name'], age=T[i]['Age'], sex=T[i]['Sex'])
        threads.append(t)
    for i in range(len(threads)):
        threads[i].start()
    for i in range(len(threads)):
        threads[i].join()
    print 'All Done!!!'
  • 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
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 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
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

运行结果：

Thread=id_0
Name=tom
Age=20
Sex=man
----------
Thread=id_1
Name=xiaohua
Age=18
Sex=woman
----------
Thread=id_2
Name=Andy
Age=40
Sex=man
----------
All Done!!!
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

可见，每个线程都可以对threading.local对象进行读写，且互相不干扰。合理使用threading.local可以极大简化代码逻辑，同时保证各个子线程的数据安全。Threading.local最大的用处就是HTTP请求时绑定用户的信息，这样每个用户线程可以非常方便访问各自的资源而互不干扰。

 

 

 

[python] view plain copy print?
  1. #coding=utf-8  
  2. import threading  
  3. # 创建全局ThreadLocal对象:  
  4. localVal = threading.local()  
  5. localVal.val = "Main-Thread"  
  6. def process_student():  
  7.     print '%s (in %s)' % (localVal.val, threading.current_thread().name)  
  8. def process_thread(name):  
  9.     #赋值  
  10.     localVal.val = name  
  11.     process_student()  
  12. t1 = threading.Thread(target= process_thread, args=('One',), name='Thread-A')  
  13. t2 = threading.Thread(target= process_thread, args=('Two',), name='Thread-B')  
  14. t1.start()  
  15. t2.start()  
  16. t1.join()  
  17. t2.join()  
  18. print localVal.val  

打印结果：

One (in Thread-A)
Two (in Thread-B)
Main-Thread

 

threading.local()这个方法的特点用来保存一个全局变量，但是这个全局变量只有在当前线程才能访问，

localVal.val = name这条语句可以储存一个变量到当前线程，如果在另外一个线程里面再次对localVal.val进行赋值，

那么会在另外一个线程单独创建内存空间来存储，也就是说在不同的线程里面赋值 不会覆盖之前的值，因为每个

线程里面都有一个单独的空间来保存这个数据,而且这个数据是隔离的，其他线程无法访问

 

这个东西可以用在那些地方呢，比如下载，现在都是多线程下载了，就像酷狗那样，可以同时下载很多首歌曲，那么

就可以利用这个方法来保存每个下载线程的数据，比如下载进度，下载速度之类的

 

所以  如果你在开发多线程应用的时候  需要每个线程保存一个单独的数据供当前线程操作，可以考虑使用这个方法，简单有效

其实这样的功能还有很多种方法可以实现，比如我们在主线程实例化一个dict对象，然后用线程的名字作为key，因为线程之间可以共享数据，

所以也可以实现相同功能，并且灵活性更多，不过代码就没那么优雅简洁了

 

 

thread:

这段时间一直在用 Python 写一个游戏的服务器程序。在编写过程中，不可避免的要用多线程来处理与客户端的交互。 python 标准库提供了 thread 和 threading 两个模块来对多线程进行支持。其中， thread 模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对 thread 进行二次封装，提供了更方便的 api 来处理线程。 虽然使用 thread 没有 threading 来的方便，但它更灵活。今天先介绍 thread 模块的基本使用，下一篇将介绍 threading 模块。

　　在介绍 thread 之前，先看一段代码，猜猜程序运行完成之后，在控制台上输出的结果是什么？

[python] view plaincopy
  1. #coding=gbk  
  2. import thread, time, random  
  3. count = 0  
  4. def threadTest():  
  5.     global count  
  6.     for i in xrange(10000):  
  7.         count += 1  
  8. for i in range(10):  
  9.     thread.start_new_thread(threadTest, ()) #如果对start_new_thread函数不是很了解，不要着急，马上就会讲解  
  10. time.sleep(3)  
  11. print count #count是多少呢？是10000 * 10 吗？  

thread.start_new_thread ( function , args [ , kwargs ] )

　　函数将创建一个新的线程，并返回该线程的标识符（标识符为整数）。参数 function 表示线程创建之后，立即执行的函数，参数 args 是该函数的参数，它是一个元组类型；第二个参数 kwargs 是可选的，它为函数提供了命名参数字典。函数执行完毕之后，线程将自动退出。如果函数在执行过程中遇到未处理的异常，该线程将退出，但不会影响其他线程的执行。 下面是一个简单的例子：

 

 

 

 

threading:

上一篇介绍了thread模块，今天来学习Python中另一个操作线程的模块：threading。threading通过对thread模块进行二次封装，提供了更方便的API来操作线程。今天内容比较多，闲话少说，现在就开始切入正题！

threading.Thread

　　Thread 是threading模块中最重要的类之一，可以使用它来创建线程。有两种方式来创建线程：一种是通过继承Thread类，重写它的run方法；另一种是创建一个threading.Thread对象，在它的初始化函数（__init__）中将可调用对象作为参数传入。下面分别举例说明。先来看看通过继承threading.Thread类来创建线程的例子：

[python] view plaincopy
  1. #coding=gbk  
  2. import threading, time, random  
  3. count = 0  
  4. class Counter(threading.Thread):  
  5.     def __init__(self, lock, threadName):  
  6.         '''''@summary: 初始化对象。 
  7.          
  8.         @param lock: 琐对象。 
  9.         @param threadName: 线程名称。 
  10.         '''  
  11.         super(Counter, self).__init__(name = threadName)  #注意：一定要显式的调用父类的初始  
  12. 化函数。  
  13.         self.lock = lock  
  14.       
  15.     def run(self):  
  16.         '''''@summary: 重写父类run方法，在线程启动后执行该方法内的代码。 
  17.         '''  
  18.         global count  
  19.         self.lock.acquire()  
  20.         for i in xrange(10000):  
  21.             count = count + 1  
  22.         self.lock.release()  
  23. lock = threading.Lock()  
  24. for i in range(5):   
  25.     Counter(lock, "thread-" + str(i)).start()  
  26. time.sleep(2)   #确保线程都执行完毕  
  27. print count  

　　在代码中，我们创建了一个Counter类，它继承了threading.Thread。初始化函数接收两个参数，一个是琐对象，另一个是线程的名称。在Counter中，重写了从父类继承的run方法，run方法将一个全局变量逐一的增加10000。在接下来的代码中，创建了五个Counter对象，分别调用其start方法。最后打印结果。这里要说明一下run方法 和start方法: 它们都是从Thread继承而来的，run()方法将在线程开启后执行，可以把相关的逻辑写到run方法中（通常把run方法称为活动[Activity]。）；start()方法用于启动线程。

 

　　再看看另外一种创建线程的方法：

[python] view plaincopy
  1. import threading, time, random  
  2. count = 0  
  3. lock = threading.Lock()  
  4. def doAdd():  
  5.     '''''@summary: 将全局变量count 逐一的增加10000。 
  6.     '''  
  7.     global count, lock  
  8.     lock.acquire()  
  9.     for i in xrange(10000):  
  10.         count = count + 1  
  11.     lock.release()  
  12. for i in range(5):  
  13.     threading.Thread(target = doAdd, args = (), name = 'thread-' + str(i)).start()  
  14. time.sleep(2)   #确保线程都执行完毕  
  15. print count  

　　在这段代码中，我们定义了方法doAdd，它将全局变量count 逐一的增加10000。然后创建了5个Thread对象，把函数对象doAdd 作为参数传给它的初始化函数，再调用Thread对象的start方法，线程启动后将执行doAdd函数。这里有必要介绍一下threading.Thread类的初始化函数原型：
def __init__(self, group=None, target=None, name=None, args=(), kwargs={})
　　参数group是预留的，用于将来扩展；
　　参数target是一个可调用对象（也称为活动[activity]），在线程启动后执行；
　　参数name是线程的名字。默认值为“Thread-N“，N是一个数字。
　　参数args和kwargs分别表示调用target时的参数列表和关键字参数。

 

Thread类还定义了以下常用方法与属性：

Thread.getName() 
Thread.setName()
Thread.name

　　用于获取和设置线程的名称。

Thread.ident

　　获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。

Thread.is_alive() 
Thread.isAlive()

　　判断线程是否是激活的（alive）。从调用start()方法启动线程，到run()方法执行完毕或遇到未处理异常而中断 这段时间内，线程是激活的。

Thread.join([timeout])

　　调用Thread.join将会使主调线程堵塞，直到被调用线程运行结束或超时。参数timeout是一个数值类型，表示超时时间，如果未提供该参数，那么主调线程将一直堵塞到被调线程结束。下面举个例子说明join()的使用：

[python] view plaincopy
  1. import threading, time  
  2. def doWaiting():  
  3.     print 'start waiting:', time.strftime('%H:%M:%S')  
  4.     time.sleep(3)  
  5.     print 'stop waiting', time.strftime('%H:%M:%S')  
  6. thread1 = threading.Thread(target = doWaiting)  
  7. thread1.start()  
  8. time.sleep(1)  #确保线程thread1已经启动  
  9. print 'start join'  
  10. thread1.join()  #将一直堵塞，直到thread1运行结束。  
  11. print 'end join'  

threading.RLock和threading.Lock

　　在threading模块中，定义两种类型的琐：threading.Lock和threading.RLock。它们之间有一点细微的区别，通过比较下面两段代码来说明：

[python] view plaincopy
  1. import threading  
  2. lock = threading.Lock() #Lock对象  
  3. lock.acquire()  
  4. lock.acquire()  #产生了死琐。  
  5. lock.release()  
  6. lock.release()  
[python] view plaincopy
  1. import threading  
  2. rLock = threading.RLock()  #RLock对象  
  3. rLock.acquire()  
  4. rLock.acquire() #在同一线程内，程序不会堵塞。  
  5. rLock.release()  
  6. rLock.release()  


　　这两种琐的主要区别是：RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

threading.Condition

　　可以把Condiftion理解为一把高级的琐，它提供了比Lock, RLock更高级的功能，允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象（默认是RLock），可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法，其含义与琐的acquire, release方法一致，其实它只是简单的调用内部琐对象的对应的方法而已。Condition还提供了如下方法(特别要注意：这些方法只有在占用琐(acquire)之后才能调用，否则将会报RuntimeError异常。)：

Condition.wait([timeout]):  

　　wait方法释放内部所占用的琐，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）。当线程被唤醒并重新占有琐的时候，程序才会继续执行下去。

Condition.notify():

　　唤醒一个挂起的线程（如果存在挂起的线程）。注意：notify()方法不会释放所占用的琐。

Condition.notify_all() 
Condition.notifyAll()

　　唤醒所有挂起的线程（如果存在挂起的线程）。注意：这些方法不会释放所占用的琐。

 

　　现在写个捉迷藏的游戏来具体介绍threading.Condition的基本使用。假设这个游戏由两个人来玩，一个藏(Hider)，一个找(Seeker)。游戏的规则如下：1. 游戏开始之后，Seeker先把自己眼睛蒙上，蒙上眼睛后，就通知Hider；2. Hider接收通知后开始找地方将自己藏起来，藏好之后，再通知Seeker可以找了； 3. Seeker接收到通知之后，就开始找Hider。Hider和Seeker都是独立的个体，在程序中用两个独立的线程来表示，在游戏过程中，两者之间的行为有一定的时序关系，我们通过Condition来控制这种时序关系。

[python] view plaincopy
  1. #---- Condition  
  2. #---- 捉迷藏的游戏  
  3. import threading, time  
  4. class Hider(threading.Thread):  
  5.     def __init__(self, cond, name):  
  6.         super(Hider, self).__init__()  
  7.         self.cond = cond  
  8.         self.name = name  
  9.       
  10.     def run(self):  
  11.         time.sleep(1) #确保先运行Seeker中的方法     
  12.           
  13.         self.cond.acquire() #b      
  14.         print self.name + ': 我已经把眼睛蒙上了'  
  15.         self.cond.notify()  
  16.         self.cond.wait() #c      
  17.                          #f   
  18.         print self.name + ': 我找到你了 ~_~'  
  19.         self.cond.notify()  
  20.         self.cond.release()  
  21.                             #g  
  22.         print self.name + ': 我赢了'   #h  
  23.           
  24. class Seeker(threading.Thread):  
  25.     def __init__(self, cond, name):  
  26.         super(Seeker, self).__init__()  
  27.         self.cond = cond  
  28.         self.name = name  
  29.     def run(self):  
  30.         self.cond.acquire()  
  31.         self.cond.wait()    #a    #释放对琐的占用，同时线程挂起在这里，直到被notify并重新占  
  32. 有琐。  
  33.                             #d  
  34.         print self.name + ': 我已经藏好了，你快来找我吧'  
  35.         self.cond.notify()  
  36.         self.cond.wait()    #e  
  37.                             #h  
  38.         self.cond.release()   
  39.         print self.name + ': 被你找到了，哎~~~'  
  40.           
  41. cond = threading.Condition()  
  42. seeker = Seeker(cond, 'seeker')  
  43. hider = Hider(cond, 'hider')  
  44. seeker.start()  
  45. hider.start()  

threading.Event

　　Event实现与Condition类似的功能，不过比Condition简单一点。它通过维护内部的标识符来实现线程间的同步问题。（threading.Event和.NET中的System.Threading.ManualResetEvent类实现同样的功能。）

Event.wait([timeout])

　　堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。

Event.set()

　　将标识位设为Ture

Event.clear()

　　将标识伴设为False。

Event.isSet()

　　判断标识位是否为Ture。

下面使用Event来实现捉迷藏的游戏(可能用Event来实现不是很形象)

[python] view plaincopy
  1. #---- Event  
  2. #---- 捉迷藏的游戏  
  3. import threading, time  
  4. class Hider(threading.Thread):  
  5.     def __init__(self, cond, name):  
  6.         super(Hider, self).__init__()  
  7.         self.cond = cond  
  8.         self.name = name  
  9.       
  10.     def run(self):  
  11.         time.sleep(1) #确保先运行Seeker中的方法     
  12.           
  13.         print self.name + ': 我已经把眼睛蒙上了'  
  14.           
  15.         self.cond.set()  
  16.           
  17.         time.sleep(1)     
  18.           
  19.         self.cond.wait()  
  20.         print self.name + ': 我找到你了 ~_~'  
  21.           
  22.         self.cond.set()  
  23.                               
  24.         print self.name + ': 我赢了'  
  25.           
  26. class Seeker(threading.Thread):  
  27.     def __init__(self, cond, name):  
  28.         super(Seeker, self).__init__()  
  29.         self.cond = cond  
  30.         self.name = name  
  31.     def run(self):  
  32.         self.cond.wait()  
  33.                           
  34.         print self.name + ': 我已经藏好了，你快来找我吧'  
  35.         self.cond.set()  
  36.           
  37.         time.sleep(1)  
  38.         self.cond.wait()  
  39.                               
  40.         print self.name + ': 被你找到了，哎~~~'  
  41.           
  42. cond = threading.Event()  
  43. seeker = Seeker(cond, 'seeker')  
  44. hider = Hider(cond, 'hider')  
  45. seeker.start()  
  46. hider.start()  

threading.Timer

　　threading.Timer是threading.Thread的子类，可以在指定时间间隔后执行某个操作。下面是python手册上提供的一个例子：

[python] view plaincopy
  1. def hello():  
  2.     print "hello, world"  
  3. t = Timer(3, hello)  
  4. t.start() # 3秒钟之后执行hello函数。  

　　threading模块中还有一些常用的方法没有介绍：

threading.active_count() 
threading.activeCount()

　　获取当前活动的(alive)线程的个数。

threading.current_thread() 
threading.currentThread()

 　　获取当前的线程对象（Thread object）。

threading.enumerate()

 　　获取当前所有活动线程的列表。

threading.settrace(func)

　　设置一个跟踪函数，用于在run()执行之前被调用。

threading.setprofile(func)

　　设置一个跟踪函数，用于在run()执行完毕之后调用。

 

　　threading模块的内容很多，一篇文章很难写全，更多关于threading模块的信息，请查询Python手册 threading 模块。

posted on 2017-08-16 21:43  myworldworld  阅读(243)  评论(0)    收藏  举报

导航