python多线程编程：简介-创建-方法-通信
2017-08-24 11:43
363 查看
转载于：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
[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的多线程的时候，基本步骤如下：
直接调用函数的多线程如下：
[python] view
plain copy
#!/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的时候，直接使用的是调用函数的方法，也就是创建线程的第一种方法，直接调用我们要进行操作的函数。
第二种方法使用的是可调用的类对象：
[python] view
plain copy
#!/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为可调用对象的实例化。
第三种方法主要就是子类化，代码如下：
[python] view
plain copy
#!/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方法进行重写。
执行结果如下：
[python] view
plain copy
[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、 线程之间的通信
具体的流程如下：
也就是生产者线程产生数据写入到共享数据中，然后消费者线程从共享数据中取出数据。
具体代码如下：
[python] view
plain copy
#!/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、线程是不是可以无限创建
一下测试为测试线程是不是可以无限创建，代码如下：
[python] view
plain copy
[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的限制，那么可以使用如下代码：
[python] view
plain copy
#!/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()
这次测试。。好像没有线程的限制。
人生苦短，我用python~
作者：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
[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的多线程的时候，基本步骤如下：
直接调用函数的多线程如下：
[python] view
plain copy
#!/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的时候，直接使用的是调用函数的方法，也就是创建线程的第一种方法，直接调用我们要进行操作的函数。
第二种方法使用的是可调用的类对象：
[python] view
plain copy
#!/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为可调用对象的实例化。
第三种方法主要就是子类化，代码如下：
[python] view
plain copy
#!/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方法进行重写。
执行结果如下：
[python] view
plain copy
[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、 线程之间的通信
具体的流程如下：
也就是生产者线程产生数据写入到共享数据中，然后消费者线程从共享数据中取出数据。
具体代码如下：
[python] view
plain copy
#!/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、线程是不是可以无限创建
一下测试为测试线程是不是可以无限创建，代码如下：
[python] view
plain copy
[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的限制，那么可以使用如下代码：
[python] view
plain copy
#!/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()
这次测试。。好像没有线程的限制。
人生苦短，我用python~
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Python并发编程之创建多线程的几种方法（二）
- Python并发编程之创建多线程的几种方法（二）
- 简介Python设计模式中的代理模式与模板方法模式编程
- python多线程编程—创建线程
- python多线程编程: python对多线程的支持和线程的创建、启动、挂起、退出
- Python基于ThreadingTCPServer创建多线程代理的方法示例
- python 8-1 如何使用多线程,Thread创建线程,执行函数赋值给target//类+函数放在run方法中执行
- python 多线程中子线程和主线程相互通信方法
- 简介Python设计模式中的代理模式与模板方法模式编程
- 多线程编程之进程、线程、进程间通信、线程间通信简介
- 多线程编程-线程间通信-join方法的使用（六）
- Java6学习笔记55——多线程编程——线程的创建方法1
- 分析Python编程时利用wxPython来支持多线程的方法
- 多线程——线程的创建以及操作线程的相关方法简介
- 多线程——线程的创建以及操作线程的相关方法简介
- Python网络编程 4.2 IPv6简介与现代地址解析--getaddrinfo()方法的使用
- Python中多线程的创建及基本调用方法
- 多线程编程——创建线程的三种方法
- Java6学习笔记56——多线程编程——线程的创建方法2
- Python中多线程的创建及基本调用方法