python多线程编程：简介-创建-方法-通信

转载于：http://blog.csdn.net/kellyseeme/article/details/51473552

作者：KEL

1、多线程的发展背景

随着计算机的发展，无论是硬件还是软件都在快速的发展。

在最开始的时候，计算机都是只有一个cpu来进行指令控制和运算，程序执行的时候都是一个进程一个进程的运行，也就是顺序执行的方式，所有的进程都是排成一个队列，然后cpu取出其中的一个进程，然后运行。

在硬件发展的时候，慢慢发展为几颗cpu，并且发展出来了几核cpu，从而在一般的服务器上都是四核的，并且至少是两颗，从而在每次服务器进行处理的时候，都是进行多进程的处理，可能说一颗cpu处理一个进程的情况出现，从而在这个时候，程序也就发展了多进程多线程的概念，在一个进程中有多个线程，而一个程序又可以运行多个线程。

在多进程和多线程主要发展出来的目标，也就是提高计算的性能，从而在这里的编程就称之为多线程编程，multi threading。

2、 Python中的多线程

在python中，多线程是存在的，但是和其他编程中的多线程是不一样的，也就是在一个进程中存在着多个线程，但是，很遗憾的是，在python中仅仅支持一个线程的运行，也就是说，在python中的多线程依旧像是单线程的运行。

在python中存在一个锁，也就是GIL，global interpreter lock，全局解释器锁，用来控制在同一时刻只有仅仅一个线程的运行。在python中，多线程的执行方式如下：

看到上面这种情况，也就是在一个进程里的确是可以有多个线程，但是同一时刻还是只有一个线程的运行，那么为什么还要使用多线程呢，用一个线程不就好了？

在python中，多线程的最好的处理的问题是对I/O密集型的操作，也就是说，在计算密集型的操作的时候，是不适合使用多线程的，因为在同一时刻，还是只有一个线程使用到cpu，但是I/O是阻塞的方式，从而python的多线程还是用在I/O操作上面，例如有大量用户的输入等IO操作。

如果是计算密集型的操作，那么在python中，更适合使用多进程的方式，在python中，使用多进程的时候，没有像线程锁的这种限制。

3、 进程和线程的区别

进程的英文表示为process，线程的英文表示为thread。

进程消耗的资源（主要是内存）比线程需要消耗的资源要多，进程具有自己独立的数据空间；而在线程中，线程都是存在于一个进程当中，从而所有的线程都是共享资源的，线程之间的数据通信很简单，而进程间的通信需要使用到IPC，inter process comminication，可能就要使用socket进行通信，线程之间的通信，可以使用一个数据结构的容器就可以进行通信，例如数据结构Queue，这个是一个先进先出的数据结构，可以用来线程之间的通信。

在运行程序的时候，操作系统管理进程，进程中存在线程，其实是进程管理线程，如果具有多个线程，那么主线程就会管理子线程，在运行程序的时候，最开始就是一个进程一个主线程，主线程会管理子线程。

在操作系统中，我们可以直接查询到进程号，也就是进程的PID，可以直接杀死一个进程，但是我们不能直接杀死一个线程，查询进程的id如下所示：

[python] view plain copy

1. [root@python 521]# ps -ef|grep server |grep -v grep  
2. root     10981  1677  0 00:28 pts/0    00:00:00 python server.py  

在其中pid为10981，从而可以使用kill命令直接杀死进程，然而并不能查到线程的pid，也就不能杀死一个线程。

线程的结束，要么是线程自己运行结束，要么就是主线程杀死子线程。

在线程中还有一个就是守护线程，守护线程，也就是在后台运行，主线程不会等待守护线程。使用守护进程的好处就是，主线程不用理会守护线程，如果主线程退出了，那么守护线程也就自动销毁了，守护线程的好处就是主线程不需要花时间来管理。

4、 python中的多线程模块介绍

在python中，多线程的模块一个是thread模块，还有一个是threading模块，推荐使用threading模块，因为threading属于高级模块，进行了大量的封装，东西总是越高级越好嘛。其实主要原因是，在thread模块中，你需要自己来进行管理子线程和主线程之间同步的问题，而在threading模块中，已经进行了相关的封装，从而不需要管同步的问题。

5、 多线程的例子

在使用python的多线程的时候，基本步骤如下：

直接调用函数的多线程如下：

[python] view plain copy

1. #!/usr/bin/env python  
2.   
3. from threading import Thread  
4. import time  
5.   
6. def loop(name,seconds):  
7.     print 'start loop',name,' at:',time.ctime()  
8.     time.sleep(1)  
9.     print 'end loop',name,' at:',time.ctime()  
10.       
11. if __name__ == '__main__':  
12.     loops = [2,4]  
13.     nloops = range(len(loops))  
14.     threads = []  
15.     print 'starting at :',time.ctime()  
16.     for i in nloops:  
17.         t = Thread(target=loop,args=(i,loops[i],))  
18.         threads.append(t)  
19.     for i in nloops:  
20.         threads[i].start()  
21.     for i in nloops:  
22.         threads[i].join()  
23.   
24.     print 'all DONE at :',time.ctime()  

在这里，主要要做的操作在loop函数中，从而创建多个线程来执行loop函数，在创建线程对象Thread的时候，直接使用的是调用函数的方法，也就是创建线程的第一种方法，直接调用我们要进行操作的函数。

第二种方法使用的是可调用的类对象：

[python] view plain copy

1. #!/usr/bin/env python  
2.   
3. from threading import Thread  
4. import time  
5.   
6. def loop(name,seconds):  
7.     print 'start loop',name,' at:',time.ctime()  
8.     time.sleep(1)  
9.     print 'end loop',name,' at:',time.ctime()  
10.       
11. class ThreadFunc(object):  
12.     def __init__(self,func,args,name=''):  
13.         self.name = name  
14.         self.func = func  
15.         self.args = args  
16.   
17.     def __call__(self):  
18.         self.func(*self.args)  
19.   
20. if __name__ == '__main__':  
21.     loops = [2,4]  
22.     nloops = range(len(loops))  
23.     threads = []  
24.     print 'starting at :',time.ctime()  
25.     for i in nloops:  
26.         t = Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))  
27.         threads.append(t)  
28.     for i in nloops:  
29.         threads[i].start()  
30.     for i in nloops:  
31.         threads[i].join()  
32.   
33.     print 'all DONE at :',time.ctime()  

在使用可调用类对象的时候，主要就是在类的定义中，需要定义个特殊的方法__call__，然后在创建Thread的时候，需要使用直接使用target为可调用对象的实例化。

第三种方法主要就是子类化，代码如下：

[python] view plain copy

1. #!/usr/bin/env python  
2.   
3. from threading import Thread  
4. import time  
5.   
6. def loop(name,seconds):  
7.     print 'start loop',name,' at:',time.ctime()  
8.     time.sleep(1)  
9.     print 'end loop',name,' at:',time.ctime()  
10.       
11. class ThreadFunc(Thread):  
12.     def __init__(self,func,args,name=''):  
13.         super(ThreadFunc,self).__init__()  
14.         self.name = name  
15.         self.func = func  
16.         self.args = args  
17.   
18.     def run(self):  
19.         self.func(*self.args)  
20.   
21. if __name__ == '__main__':  
22.     loops = [2,4]  
23.     nloops = range(len(loops))  
24.     threads = []  
25.     print 'starting at :',time.ctime()  
26.     for i in nloops:  
27.         t = ThreadFunc(loop,(i,loops[i]),loop.__name__)  
28.         threads.append(t)  
29.     for i in nloops:  
30.         threads[i].start()  
31.     for i in nloops:  
32.         threads[i].join()  
33.   
34.     print 'all DONE at :',time.ctime()  

这种方法和第二种方法大同小异，主要就是在子类的时候集成Thread类，然后将可调用的方法修改为run方法即可，在Thread类对象中，如果需要继承，那么主要就是将run方法进行重写。

执行结果如下：

[python] view plain copy

1. [root@python 522]# python thread_demo.py   
2. starting at : Sun May 22 03:44:49 2016  
3. start loop 0  at: Sun May 22 03:44:49 2016  
4. start loop 1  at: Sun May 22 03:44:49 2016  
5. end loop 0  at: Sun May 22 03:44:50 2016  
6. end loop 1  at: Sun May 22 03:44:50 2016  
7. all DONE at : Sun May 22 03:44:50 2016  

在一般推荐的方法中，是使用第三种方法，也就是子类化Thread类。

在这里用了三个循环，主要的目的是在进行创建的时候，不需要开启线程，从而在第二循环中，开启所有的线程。

6、 Thread基本方法

在threading的Thread类中，主要的方法是run方法，也就是在使用target初始化的时候关联的方法。

Thread实例的时候，提供target参数，就是需要执行的函数，另外一个args参数就是函数的参数，必须用元祖的形式提供，如果只有一个参数，必须在一个参数后加一个逗号，表示为元祖。

join表示主线程需不需要等待子线程，如果不需要，那么可以不调用join函数，在上面例子中，调用了join函数，从而主线程需要等待子线程，在使用了timeout参数之后，那么会表示主线程最多等多少秒，然后继续执行主线程，主线程结束，那么会将子线程结束掉

setDaemon是设置线程为守护线程，守护线程表示一个不重要线程，主线程结束，那么守护线程也就结束了，可以使用方法isDaemon来判断是否为守护线程

getname表示返回线程的名称，setname表示设置线程的名称，isalive表示线程是否还在运行

在设置守护线程的时候，必须在启动方法也就是start之前进行设置。

7、 线程之间的通信

具体的流程如下：

也就是生产者线程产生数据写入到共享数据中，然后消费者线程从共享数据中取出数据。

具体代码如下：

[python] view plain copy

1. #!/usr/bin/env python  
2.   
3. from threading import Thread  
4. import time  
5. from Queue import Queue  
6.   
7. def writeQ(queue,i):  
8.     while True:  
9.         time.sleep(1)  
10.         if queue.full():  
11.             time.sleep(1)  
12.         else:  
13.             queue.put('xxx')  
14.             print 'producting object for Q..',i  
15.   
16. def readQ(queue,i):  
17.     while True:  
18.         time.sleep(1)  
19.         if queue.empty():  
20.             time.sleep(1)  
21.             print 'empty'  
22.         else:  
23.             val = queue.get()  
24.             print 'consumed object from Q..size now:',queue.qsize(),' consumer ' ,i  
25.   
26. class Producter(Thread):  
27.     def __init__(self,func,args,name=''):  
28.         super(Producter,self).__init__()  
29.         self.name = name  
30.         self.args = args  
31.         self.func = func  
32.   
33.     def run(self):  
34.         self.res = self.func(*self.args)  
35.         #return self.res  
36.   
37. class Consumer(Thread):  
38.     def __init__(self,func,args,name=''):  
39.         super(Consumer,self).__init__()  
40.         self.name = name  
41.         self.args = args  
42.         self.func = func  
43.   
44.     def run(self):  
45.         self.res = self.func(*self.args)  
46.         #return self.res  
47.   
48. if __name__ =='__main__':  
49.     q = Queue(100)  
50.     for i in range(20):  
51.         p = Producter(writeQ,(q,'production %s ' % i))  
52.         p.start()  
53.     for i in range(2):  
54.         c = Consumer(readQ,(q,'consumer %s ' % i))  
55.         c.start()  

在其中，主要就是使用Queue进行线程间的通信，在以上的代码中，可以进行优化，例如提取公共类，派生子类生产者和消费者。

8、线程是不是可以无限创建

一下测试为测试线程是不是可以无限创建，代码如下：

[python] view plain copy

1. [root@python 522]# cat thread_test.py   
2. #!/usr/bin/env python  
3.   
4. from threading import Thread  
5.   
6. def testThread():  
7.     while True:  
8.         pass  
9. while True:  
10.     t = Thread(target=testThread)  
11.     t.start()  

就是无限的创建线程。

vmstat基准线如下：

指标解释如下：

r表示运行的队列，话说超过5，就很有压力了

in表示中断的次数

cs表示上下文切换

us表示用户cpu时间

sy表示系统的cpu时间

运行一段时间后，发现，这个procs的r数量增长很快，那么表示，有多少个的线程分配到了cpu

看出来，cpu很繁忙，中断的次数和上下文切换的数量很大，而且用户的cpu时间占比比较多。

在这个时候，登录系统的时候，会发现系统非常卡，可以看出来脑子。。。CPU根本不够用了。

杀掉进程之后恢复正常。。那么去掉cpu的限制，那么可以使用如下代码：

[python] view plain copy

1. #!/usr/bin/env python  
2.   
3. from threading import Thread  
4. from time import sleep  
5.   
6. i=0  
7. def testThread():  
8.     print i   
9.   
10. while True:  
11.     i += 1  
12.     t = Thread(target=testThread)  
13.     t.start()  

这次测试。。好像没有线程的限制。

人生苦短，我用python~