一、Python
中的线程使用:
Python
中使用线程有两种方式:函数或者用类来包装线程对象。
1、
函数式:调用
thread
模块中的
start_new_thread()
函数来产生新线程。如下例:
import time
import thread
def timer(no, interval):
cnt = 0
while cnt<10:
print 'Thread:(%d) Time:%s\n'%(no, time.ctime())
time.sleep(interval)
cnt+=1
thread.exit_thread()
def test(): #Use thread.start_new_thread() to create 2 new threads
thread.start_new_thread(timer, (1,1))
thread.start_new_thread(timer, (2,2))
if __name__=='__main__':
test()
上面的例子定义了一个线程函数
timer,
它打印出
10
条时间记录后退出,每次打印的间隔由
interval
参数决定。
thread.start_new_thread(function, args[, kwargs])
的第一个参数是线程函数(本例中的
timer
方法),第二个参数是传递给线程函数的参数,它必须是
tuple
类型,
kwargs
是可选参数。
线程的结束可以等待线程自然结束,也可以在线程函数中调用
thread.exit()
或
thread.exit_thread()
方法。
2、
创建
threading.Thread
的子类来包装一个线程对象,如下例:
import threading
import time
class timer(threading.Thread): #The timer class is derived from the class threading.Thread
def __init__(self, num, interval):
threading.Thread.__init__(self)
self.thread_num = num
self.interval = interval
self.thread_stop = False
def run(self): #Overwrite run() method, put what you want the thread do here
while not self.thread_stop:
print 'Thread Object(%d), Time:%s/n' %(self.thread_num, time.ctime())
time.sleep(self.interval)
def stop(self):
self.thread_stop = True
def test():
thread1 = timer(1, 1)
thread2 = timer(2, 2)
thread1.start()
thread2.start()
time.sleep(10)
thread1.stop()
thread2.stop()
return
if __name__ == '__main__':
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
模块本身也提供了很多方法和其他的类,可以帮助我们更好的使用和管理线程。可以参看
http://www.python.org/doc/2.5.2/lib/module-threading.html
。
假设两个线程对象
t1
和
t2
都要对
num=0
进行增
1
运算,
t1
和
t2
都各对
num
修改
10
次,
num
的最终的结果应该为
20
。但是由于是多线程访问,有可能出现下面情况:在
num=0
时,
t1
取得
num=0
。系统此时把
t1
调度为
”sleeping”
状态,把
t2
转换为
”running”
状态,
t2
页获得
num=0
。然后
t2
对得到的值进行加
1
并赋给
num
,使得
num=1
。然后系统又把
t2
调度为
”sleeping”
,把
t1
转为
”running”
。线程
t1
又把它之前得到的
0
加
1
后赋值给
num
。这样,明明
t1
和
t2
都完成了
1
次加
1
工作,但结果仍然是
num=1
。
上面的
case
描述了多线程情况下最常见的问题之一:数据共享。当多个线程都要去修改某一个共享数据的时候,我们需要对数据访问进行同步。
1、
简单的同步
最简单的同步机制就是“锁”。锁对象由
threading.RLock
类创建。线程可以使用锁的
acquire()
方法获得锁,这样锁就进入“
locked
”状态。每次只有一个线程可以获得锁。如果当另一个线程试图获得这个锁的时候,就会被系统变为“
blocked
”状态,直到那个拥有锁的线程调用锁的
release()
方法来释放锁,这样锁就会进入“
unlocked
”状态。“
blocked
”状态的线程就会收到一个通知,并有权利获得锁。如果多个线程处于“
blocked
”状态,所有线程都会先解除“
blocked
”状态,然后系统选择一个线程来获得锁,其他的线程继续沉默(“
blocked
”)。
Python
中的
thread
模块和
Lock
对象是
Python
提供的低级线程控制工具,使用起来非常简单。如下例所示:
import thread
import time
mylock = thread.allocate_lock() #Allocate a lock
num=0 #Shared resource
def add_num(name):
global num
while True:
mylock.acquire() #Get the lock
# Do something to the shared resource
print 'Thread %s locked! num=%s'%(name,str(num))
if num >= 5:
print 'Thread %s released! num=%s'%(name,str(num))
mylock.release()
thread.exit_thread()
num+=1
print 'Thread %s released! num=%s'%(name,str(num))
mylock.release() #Release the lock.
def test():
thread.start_new_thread(add_num, ('A',))
thread.start_new_thread(add_num, ('B',))
if __name__== '__main__':
test()
Python
在
thread
的基础上还提供了一个高级的线程控制库,就是之前提到过的
threading
。
Python
的
threading module
是在建立在
thread module
基础之上的一个
module
,在
threading module
中,暴露了许多
thread module
中的属性。在
thread module
中,
python
提供了用户级的线程同步工具“
Lock
”对象。而在
threading module
中,
python
又提供了
Lock
对象的变种
: RLock
对象。
RLock
对象内部维护着一个
Lock
对象,它是一种可重入的对象。对于
Lock
对象而言,如果一个线程连续两次进行
acquire
操作,那么由于第一次
acquire
之后没有
release
,第二次
acquire
将挂起线程。这会导致
Lock
对象永远不会
release
,使得线程死锁。
RLock
对象允许一个线程多次对其进行
acquire
操作,因为在其内部通过一个
counter
变量维护着线程
acquire
的次数。而且每一次的
acquire
操作必须有一个
release
操作与之对应,在所有的
release
操作完成之后,别的线程才能申请该
RLock
对象。
下面来看看如何使用
threading
的
RLock
对象实现同步。
import threading
mylock = threading.RLock()
num=0
class myThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.t_name = name
def run(self):
global num
while True:
mylock.acquire()
print '/nThread(%s) locked, Number: %d'%(self.t_name, num)
if num>=4:
mylock.release()
print '/nThread(%s) released, Number: %d'%(self.t_name, num)
break
num+=1
print '/nThread(%s) released, Number: %d'%(self.t_name, num)
mylock.release()
def test():
thread1 = myThread('A')
thread2 = myThread('B')
thread1.start()
thread2.start()
if __name__== '__main__':
test()
我们把修改共享数据的代码成为“临界区”。必须将所有“临界区”都封闭在同一个锁对象的
acquire
和
release
之间。
2、
条件同步
锁只能提供最基本的同步。假如只在发生某些事件时才访问一个“临界区”,这时需要使用条件变量
Condition
。
Condition
对象是对
Lock
对象的包装,在创建
Condition
对象时,其构造函数需要一个
Lock
对象作为参数,如果没有这个
Lock
对象参数,
Condition
将在内部自行创建一个
Rlock
对象。在
Condition
对象上,当然也可以调用
acquire
和
release
操作,因为内部的
Lock
对象本身就支持这些操作。但是
Condition
的价值在于其提供的
wait
和
notify
的语义。
条件变量是如何工作的呢?首先一个线程成功获得一个条件变量后,调用此条件变量的
wait()
方法会导致这个线程释放这个锁,并进入“
blocked
”状态,直到另一个线程调用同一个条件变量的
notify()
方法来唤醒那个进入“
blocked
”状态的线程。如果调用这个条件变量的
notifyAll()
方法的话就会唤醒所有的在等待的线程。
如果程序或者线程永远处于“
blocked
”状态的话,就会发生死锁。所以如果使用了锁、条件变量等同步机制的话,一定要注意仔细检查,防止死锁情况的发生。对于可能产生异常的临界区要使用异常处理机制中的
finally
子句来保证释放锁。等待一个条件变量的线程必须用
notify()
方法显式的唤醒,否则就永远沉默。保证每一个
wait()
方法调用都有一个相对应的
notify()
调用,当然也可以调用
notifyAll()
方法以防万一。
生产者与消费者问题是典型的同步问题。这里简单介绍两种不同的实现方法。
1,
条件变量
import threading
import time
class Producer(threading.Thread):
def __init__(self, t_name):
threading.Thread.__init__(self, name=t_name)
def run(self):
global x
con.acquire()
if x > 0:
con.wait()
else:
for i in range(5):
x=x+1
print "producing..." + str(x)
con.notify()
print x
con.release()
class Consumer(threading.Thread):
def __init__(self, t_name):
threading.Thread.__init__(self, name=t_name)
def run(self):
global x
con.acquire()
if x == 0:
print 'consumer wait1'
con.wait()
else:
for i in range(5):
x=x-1
print "consuming..." + str(x)
con.notify()
print x
con.release()
con = threading.Condition()
x=0
print 'start consumer'
c=Consumer('consumer')
print 'start producer'
p=Producer('producer')
p.start()
c.start()
p.join()
c.join()
print x
上面的例子中,在初始状态下,
Consumer
处于
wait
状态,
Producer
连续生产(对
x
执行增
1
操作)
5
次后,
notify
正在等待的
Consumer
。
Consumer
被唤醒开始消费(对
x
执行减
1
操作)
2,
同步队列
Python
中的
Queue
对象也提供了对线程同步的支持。使用
Queue
对象可以实现多个生产者和多个消费者形成的
FIFO
的队列。
生产者将数据依次存入队列,消费者依次从队列中取出数据。
# producer_consumer_queue
from Queue import Queue
import random
import threading
import time
#Producer thread
class Producer(threading.Thread):
def __init__(self, t_name, queue):
threading.Thread.__init__(self, name=t_name)
self.data=queue
def run(self):
for i in range(5):
print "%s: %s is producing %d to the queue!/n" %(time.ctime(), self.getName(), i)
self.data.put(i)
time.sleep(random.randrange(10)/5)
print "%s: %s finished!" %(time.ctime(), self.getName())
#Consumer thread
class Consumer(threading.Thread):
def __init__(self, t_name, queue):
threading.Thread.__init__(self, name=t_name)
self.data=queue
def run(self):
for i in range(5):
val = self.data.get()
print "%s: %s is consuming. %d in the queue is consumed!/n" %(time.ctime(), self.getName(), val)
time.sleep(random.randrange(10))
print "%s: %s finished!" %(time.ctime(), self.getName())
#Main thread
def main():
queue = Queue()
producer = Producer('Pro.', queue)
consumer = Consumer('Con.', queue)
producer.start()
consumer.start()
producer.join()
consumer.join()
print 'All threads terminate!'
if __name__ == '__main__':
main()
在上面的例子中,
Producer
在随机的时间内生产一个“产品”,放入队列中。
Consumer
发现队列中有了“产品”,就去消费它。本例中,由于
Producer
生产的速度快于
Consumer
消费的速度,所以往往
Producer
生产好几个“产品”后,
Consumer
才消费一个产品。
Queue
模块实现了一个支持多
producer
和多
consumer
的
FIFO
队列。当共享信息需要安全的在多线程之间交换时,
Queue
非常有用。
Queue
的默认长度是无限的,但是可以设置其构造函数的
maxsize
参数来设定其长度。
Queue
的
put
方法在队尾插入,该方法的原型是:
put(
item[, block[, timeout]])
如果可选参数
block
为
true
并且
timeout
为
None
(缺省值),线程被
block
,直到队列空出一个数据单元。如果
timeout
大于
0
,在
timeout
的时间内,仍然没有可用的数据单元,
Full exception
被抛出。反之,如果
block
参数为
false
(忽略
timeout
参数),
item
被立即加入到空闲数据单元中,如果没有空闲数据单元,
Full exception
被抛出。
Queue
的
get
方法是从队首取数据,其参数和
put
方法一样。如果
block
参数为
true
且
timeout
为
None
(缺省值),线程被
block
,直到队列中有数据。如果
timeout
大于
0
,在
timeout
时间内,仍然没有可取数据,
Empty exception
被抛出。反之,如果
block
参数为
false
(忽略
timeout
参数),队列中的数据被立即取出。如果此时没有可取数据,
Empty exception
也会被抛出。
分享到:
相关推荐
Python中使用线程有两种方式:函数或者用类来包装线程对象
Python多线程学习教程
threading模块和thread模块练习
这个是在学习python多线程的时候自己总结的文档,对理解Python多线程非常有帮助,很多都是从官方文档而来的。
程序运行起来,叫进程,进程是资源分配的单位,线程执行代码,一个线程只能执行一个任务,想要执行多个任务,就需要多线程 协程依赖于线程,线程依赖于进程,协程切换需要资源相当少,所以效率就会很高 重构:把...
python多线程编程,适合进阶型学习者,实现多线程下的编程。
pythonthread(Python多线程处理).docx
Python多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zip 运行python的时候,...
Python3的多线程学习笔记[定义].pdf
多线程学习,通过两个函数来测试多线程的运行原理,运行时可以反复看时间的先后
这是python多线程学习的一些资料,希望能帮助大家!
这篇文章主要介绍了python多线程并发及测试框架案例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1、循环创建多个线程,并通过循环启动执行 import ...
主要介绍了Python多线程下的list的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
PyQt5中异步刷新UI和Python中的多线程总结 学习python和PyQt5的过程中,做了demo,可以从电脑端向手push文件和安装apk的GUIdemo,初学者可从这个例子中学到很多知识。涉及到PyQt5中异步刷新UI+Python中的多线程+...
python基础_31_Python_threading_1_什么是多线程_(教学教程tutorial)
当然是多线程的优势已经掩盖了它本身不足之处,所以我们来加强一下学习python多线程的信心吧~ 总结起来,使用多线程编程具有如下几个优点: 进程之间不能共享内存,但线程之间共享内存非常容易。 操作系统在创建进程...
批量爬虫下载时,单线程下载文件有时慢有时快。...同时附上单线程下载(带进度条显示功能)代码,单线程下载(带进度条显示)和多线程代码的时间比较,实测多线程能有效提升下载效率,效果还是比较不错的。
python学习笔记; 内容包括:信号与槽; 多线程 类的学习
对python并发进行的笔记整理,个人所学习使用,主要包括多进程,多线程,协程,IO多路复用,进程线程通信等