python多线程编程

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如下所示：

[root@python 521]# ps -ef|grep server |grep -v grep
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的多线程的时候，基本步骤如下：



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

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
print 'start loop',name,' at:',time.ctime()
time.sleep(1)
print 'end loop',name,' at:',time.ctime()

if __name__ == '__main__':
loops = [2,4]
nloops = range(len(loops))
threads = []
print 'starting at :',time.ctime()
for i in nloops:
t = 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 :',time.ctime()

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

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

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
print 'start loop',name,' at:',time.ctime()
time.sleep(1)
print 'end loop',name,' at:',time.ctime()

class ThreadFunc(object):
def __init__(self,func,args,name=''):
self.name = name
self.func = func
self.args = args

def __call__(self):
self.func(*self.args)

if __name__ == '__main__':
loops = [2,4]
nloops = range(len(loops))
threads = []
print 'starting at :',time.ctime()
for i in nloops:
t = 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 :',time.ctime()

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

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

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
print 'start loop',name,' at:',time.ctime()
time.sleep(1)
print 'end loop',name,' at:',time.ctime()

class ThreadFunc(Thread):
def __init__(self,func,args,name=''):
super(ThreadFunc,self).__init__()
self.name = name
self.func = func
self.args = args

def run(self):
self.func(*self.args)

if __name__ == '__main__':
loops = [2,4]
nloops = range(len(loops))
threads = []
print 'starting at :',time.ctime()
for i in nloops:
t = 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 :',time.ctime()

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

执行结果如下：

[root@python 522]# python thread_demo.py
starting at : Sun May 22 03:44:49 2016
start loop 0  at: Sun May 22 03:44:49 2016
start loop 1  at: Sun May 22 03:44:49 2016
end loop 0  at: Sun May 22 03:44:50 2016
end loop 1  at: Sun May 22 03:44:50 2016
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、 线程之间的通信

具体的流程如下：



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

具体代码如下：

#!/usr/bin/env python

from threading import Thread
import time
from Queue import Queue

def writeQ(queue,i):
while True:
time.sleep(1)
if queue.full():
time.sleep(1)
else:
queue.put('xxx')
print 'producting object for Q..',i

def readQ(queue,i):
while True:
time.sleep(1)
if queue.empty():
time.sleep(1)
print 'empty'
else:
val = queue.get()
print 'consumed object from Q..size now:',queue.qsize(),' consumer ' ,i

class Producter(Thread):
def __init__(self,func,args,name=''):
super(Producter,self).__init__()
self.name = name
self.args = args
self.func = func

def run(self):
self.res = self.func(*self.args)
#return self.res

class Consumer(Thread):
def __init__(self,func,args,name=''):
super(Consumer,self).__init__()
self.name = name
self.args = args
self.func = func

def run(self):
self.res = self.func(*self.args)
#return self.res

if __name__ =='__main__':
q = Queue(100)
for i in range(20):
p = Producter(writeQ,(q,'production %s ' % i))
p.start()
for i in range(2):
c = Consumer(readQ,(q,'consumer %s ' % i))
c.start()

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

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

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

[root@python 522]# cat thread_test.py
#!/usr/bin/env python

from threading import Thread

def testThread():
while True:
pass
while True:
t = Thread(target=testThread)
t.start()

就是无限的创建线程。

vmstat基准线如下：



指标解释如下：

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

in 表示中断的次数

cs 表示上下文切换

us 表示用户cpu时间

sy 表示系统的cpu时间



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

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

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

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

#!/usr/bin/env python

from threading import Thread
from time import sleep

i=0
def testThread():
print i

while True:
i += 1
t = Thread(target=testThread)
t.start()

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