多线程编程

来源:互联网 发布:矩阵分解模型 编辑:程序博客网 时间:2024/03/28 19:35

进程是操作系统中应用程序的执行实例,而线程是进程内部的一个执行单元。当系统创建一个进程后,也就创建了一个主线程。每个进程至少有一个线程,也可以有多个线程。在程序中使用多线程可以实现并行处理,充分利用CPU。Python提供了对多线程的支持。在Python中可以方便地使用多线程进行编程。

9.1  线程基础

Python提供了thread、threading模块对多线程编程的支持。threading模块是对thread模块的封装。多数情况下应该是用threading模块来进行多线程编程。

9.1.1  创建线程

在Python中可以通过使用thread模块中的函数,或者通过继承threading类来创建线程。编程创建后还可以对其进行操作。

1.使用thread模块创建线程

thread模块提供了start_new_thread函数,用以创建线程。start_new_thread函数成功创建线程后将返回线程标识。其函数原型如下所示。
start_new_thread( function, args[, kwargs])

其参数含义如下。

function:在线程中执行的函数名。

args:元组形式的参数列表。

kwargs:可选参数,以字典的形式指定参数。

以下代码首先定义一个函数,然后使用start_new_thread创建一个线程运行该函数。

    

>>> import thread      # 导入thread模块
>>> def run(n):       # 定义run函数
...  for i in range(n):
...   print i
...   
>>> thread.start_new_thread(run,(4,))  # 使用start_new_thread函数创建线程
3668          # 返回线程的标识
>>> 0         # 此处为run函数的输出
1
2
3
>>> thread.start_new_thread(run,(2,))  # 使用start_new_thread函数创建线程
1388          # 返回线程的标识
>>> 0         # 此处为run函数的输出
1
>>> thread.start_new_thread(run,(),{'n':4}) # 使用字典向函数传递参数
3896
>>> 0
1
2
3

2.使用threading模块创建线程

通过继承threading模块中的Thread创建新类,重载run方法后,可以通过start方法创建线程。线程创建后将运行run方法。以下代码使用threading模块创建线程。

    

>>> import threading      # 导入threading模块
>>> class mythread(threading.Thread):  # 通过继承Thread创建类
...   def _init_(self,num):    # 定义初始化方法
...   threading.Thread.__init__(self)  # 调用父类的初始化方法
...   self.num = num
...   def run(self):      # 重载run方法
...   print 'I am ',self.num
...   
>>> t1 = mythread(1)      # 生成mythread对象
>>> t2 = mythread(2)      # 生成mythread对象
>>> t3 = mythread(3)      # 生成mythread对象
>>> t1.start()       # 运行线程t1,实际上是运行run方法
I am  1
>>> t2.start()       # 运行线程t2
I am  2
>>> t3.start()       # 运行线程t3
I am  3

除了通过继承threading.Thread创建类以外,还可以通过使用threading.Thread直接在线程中运行函数。以下代码使用threading.Thread直接创建线程。

    

>>> import threading         # 导入threading模块
>>> def run(x,y):         # 定义run函数
...   for i in range(x,y):
...   print I
...   
>>> t1 = threading.Thread(target = run,args = (15,20))  # 直接使用Thread附加函数,
  args为函数参数
>>> t1.start()          # 运行线程
15
16
17
18
19
>>> t2 = threading.Thread(target = run,args = (7,11))  # 直接使用Thread附加函数,
  args为函数参数
>>> t2.start()          # 运行线程
7
8
9
10

 

 

 

 

 

9.1.2  Thread对象中的方法

在上一节的例子中,仅使用了Thread对象中的sart方法,重载了Thread对象的run方法。当线程被运行时,将运行run方法。Thread对象还具有以下的几种方法。

1.join方法

如果一个线程或者在函数的执行过程中调用另一个线程,并且待其完成操作后才能执行,那么在调用线程时可以使用被调用线程的join方法。join方法的原型如下所示。

join([timeout])

其参数含义如下。

timeout:可选参数,线程运行的最长时间。

以下代码使用Thread对象的join方法等待线程完成操作。

   

>>> import threading      # 导入threading模块
>>> import time       # 导入time模块
>>> class Mythread(threading.Thread):  # 通过继承Thread创建类
...   def _init_(self,id):    # 初始化方法
...   threading.Thread._init_(self)  # 调用父类的初始化方法
...   self.id = id
...   def run(self):      # 重载run方法
...   x = 0
...   time.sleep(60)     # 使用time模块中的sleep方法让线程休眠60s
...   print self.id
...   
>>> def func():       # 定义函数
...   t.start()       # 运行线程
...   for i in range(5):
...   print i
...   
>>> t = Mythread(2)      # 生成Mythread对象
>>> func()        # 调用函数,运行线程
0          # 输出结果中没有线程的输出,func函数没有等待
  线程完成
1
2
3
4
>>> def func():       # 重新定义func函数
...   t.start()       # 执行函数,运行线程
...   t.join()       # 调用join方法等待线程完成
...   for i in range(5):
...   print i
...   
>>> t = Mythread(3)      # 生成Mythread对象
>>> func()        # 调用函数,运行线程
3          # 此为线程输出
0
1
2
3
4

2.isAlive方法

当线程创建后,可以使用Thread对象的isAlive方法查看线程是否运行。如下代码使用Thread对象的isAlive方法查看线程是否运行。

    >>> import threading      # 导入threading模块
>>> import time       # 导入time模块
>>> class mythread(threading.Thread):  # 通过继承Thread创建类
...   def _init_(self,id):    # 初始化方法
...   threading.Thread._init_(self)  # 调用父类的初始化方法
...   self.id = id
...   def run(self):      # 重载run方法
...   time.sleep(5)
...   print self.id
...   
>>> t = mythread(1)      # 生成mythread对象
>>> def func():       # 定义函数
...   t.start()       # 运行线程
...   print t.isAlive()     # 打印线程状态
...  
>>> func()        # 调用函数
True          # 线程状态
>>> 1
# 线程输出

3.线程名

当线程创建后可以设置线程名来区分不同的线程,以便对线程进行控制。线程名可以在类的初始化函数中定义,也可以使用Thread对象setName方法设置线程名。使用Thread对象的getName方法可以获得线程名。以下代码使用不同方法设置线程名。

   

>>> import threading          # 导入threading模块
>>> class mythread(threading.Thread):      # 通过继承Thread创建类
...   def _init_(self,threadname):
...     threading.Thread._init_(self,name = threadname)  # 初始化线程名
...   def run(self):          # 重载run方法
...     print self.getName()
...   
>>> t1 = mythread('t1')        # 类实例化,设置线程名
>>> t1.getName()          # 调用getName方法获得线程名
't1'
>>> t1.setName('T')         # 调用setName方法设置线程名
>>> t1.getName()          # 调用getName方法获得线程名
'T'
>>> t2 = mythread('t2')        # 类实例化,设置线程名
>>> t2.start()          # 运行线程
t2
>>> t2.getName()          # 调用getName方法获得线程名
't2'
>>> t2.setName('TT')         # 调用setName方法设置线程名
>>> t2.getName()          # 调用getName方法获得线程名
'TT'

4.setDaemon方法

在脚本运行过程中有一个主线程,如果主线程又创建一个子线程,那么当主线程退出时,会检验子线程是否完成。如果子线程未完成,则主线程会等待子线程完成后再退出。当需要主线程退出时,不管子线程是否完成都随主线程退出,则可以使用Thread对象的setDaemon方法来设置。以下代码使用Thread对象的setDaemon方法设置线程随主线程结束而结束

    

# -*- coding:utf-8 -*-
# file: threaddaemon.py
#
import threading          # 导入threading模块
import time           # 导入time模块
class mythread(threading.Thread):      # 通过继承创建类
def _init_(self,threadname):      # 初始化方法
threading.Thread._init_(self,name = threadname)   # 调用父类的初始化方法
def run(self):         # 重载run方法
time.sleep(5)         # 调用time.sleep函数,让线
 程休眠5s 
print self.getName()
def func1():           # 定义函数func1
t1.start()
print 'func1 done'
def func2():           # 定义函数func2
t2.start()
print 'func2 done'
t1 = mythread('t1')         # 类实例化
t2 = mythread('t2')         # 类实例化
t2.setDaemon(True)         # 设置t2的Daemon标志
func1()            # 调用函数func1
func2()            # 调用函数func2
运行threaddaemon.py脚本输出如下所示。
func1 done
func2 done
t1

由于调用了线程t2的setDaemon方法,当主线程结束时,线程t2也随之结束。因此,t2还没来得及打印自己的线程名,就已经结束。将threaddaemon.py脚本中的“t2.setDaemon(True)”删除后,保存脚本。重新运行threaddaemon.py脚本,脚本输出如下所示。

    

func1 done
func2 done
t1
t2

修改后的脚本要等待所有子线程完成后才会退出,因此,线程t1和线程t2都被执行完。如果在交互式模式下运行该实例,则不会有区别,因为,在交互式模式下的主线程只有在退出Python时才终止。

原创粉丝点击