函数式和包装对象两种并行处理数据方法的比较

在处理高通量数据中，实现“并行”对于优化运行效率至关重要，常规的并行方法很多。今天我们比较并介绍其中两种方法的区别和实现方法，这两种方法分别是函数式方法和包装对象法。

1、  函数式：调用thread模块中的start_new_thread()函数来产生新线程。如下例：

1. import time  

2. import thread  

3. def timer(no, interval):  

4.     cnt = 0  

5.     while cnt<10:  

6.         print 'Thread:(%d) Time:%s/n'%(no, time.ctime())  

7.         time.sleep(interval)  

8.         cnt+=1  

9.     thread.exit_thread()  

10.      

11.    

12. def test(): #Use thread.start_new_thread() to create 2 new threads  

13.     thread.start_new_thread(timer, (1,1))  

14.     thread.start_new_thread(timer, (2,2))  

15.    

16. if __name__=='__main__':  

17.     test()  

       上面的例子定义了一个线程函数timer,它打印出10条时间记录后退出，每次打印的间隔由interval参数决定。thread.start_new_thread(function, args[,kwargs])的第一个参数是线程函数（本例中的timer方法），第二个参数是传递给线程函数的参数，它必须是tuple类型，kwargs是可选参数。

       线程的结束可以等待线程自然结束，也可以在线程函数中调用thread.exit()或thread.exit_thread()方法。

2、  创建threading.Thread的子类

创建子类来包装一个线程对象，如下例：

1. import threading  

2. import time  

3. class timer(threading.Thread): #The timer class is derived from the class threading.Thread  

4.     def __init__(self, num, interval):  

5.         threading.Thread.__init__(self)  

6.         self.thread_num = num  

7.         self.interval = interval  

8.         self.thread_stop = False  

9.    

10.     def run(self): #Overwrite run() method, put what you want the thread do here  

11.         while not self.thread_stop:  

12.             print 'Thread Object(%d), Time:%s/n' %(self.thread_num, time.ctime())  

13.             time.sleep(self.interval)  

14.     def stop(self):  

15.         self.thread_stop = True  

16.          

17.    

18. def test():  

19.     thread1 = timer(1, 1)  

20.     thread2 = timer(2, 2)  

21.     thread1.start()  

22.     thread2.start()  

23.     time.sleep(10)  

24.     thread1.stop()  

25.     thread2.stop()  

26.     return  

27.    

28. if __name__ == '__main__':  

29.     test()  

       就我个人而言，比较喜欢第二种方式，即创建自己的线程类，必要时重写threading.Thread类的方法，线程的控制可以由自己定制。

threading.Thread类的使用：

1，在自己的线程类的__init__里调用threading.Thread.__init__(self, name =threadname)

Threadname为线程的名字

2， run()，通常需要重写，编写代码实现做需要的功能。

3，getName()，获得线程对象名称

4，setName()，设置线程对象名称

5，start()，启动线程

6，jion([timeout])，等待另一线程结束后再运行。

7，setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。

8，isDaemon()，判断线程是否随主线程一起结束。

9，isAlive()，检查线程是否在运行中。

    此外threading模块本身也提供了很多方法和其他的类，可以帮助我们更好的使用和管理线程。

欢迎后台留言，一起进行学习奥~~

----------------------------------------------------------------------------------------------------