python多线程基础
一、python多线程基础python多线程主要涉及两个类：thread和threading，后者实际是对前者的封装，由于threading提供了更完善的锁机制，运用场景更多，重点学习了这个类的使用。
threading.Thread类的使用：1、在自己的线程类的__init__里调用threading.Thread.__init__(self, name = threadname)，threadname为线程的名字2、 run()，通常需要重写，编写代码实现做需要的功能。3、getName()，获得线程对象名称4、setName()，设置线程对象名称5、start()，启动线程6、join()，等待另一线程结束后再运行。7、setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。8、isDaemon()，判断线程是否随主线程一起结束。9、isAlive()，检查线程是否在运行中。例子如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import threading
import time
#继承threading.Thread类
class timer(threading.Thread):
def __init__(self, num, interval):
threading.Thread.__init__(self)
self.thread_num = num
self.interval = interval
self.thread_stop = False
#重新run()方法
def run(self):
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类后重写run方法可以实现我们想做的事情，另一种实现多线程的方法是通过threading.Thread类直接生成线程，同时直接指定线程要执行的方法以及方法相应的参数。见以下例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
import threading
def runTest(x,y):
for i in range(x,y):
print i
t1 = threading.Thread(target=runTest,args=(15,20))
t2 = threading.Thread(target=runTest,args=(25,35))
t1.start()
t2.start()
t1.join()
t2.join()
二、线程同步
1、简单的同步
通过锁是实现同步最简单的方式。python的锁对象由thread.Lock类创建。基本流程如下：
1）线程可以使用锁的acquire()方法获得锁，这样锁就进入“locked”状态；
2）每次只有一个线程可以获得锁，如果当另一个线程试图获得这个锁的时候，就会被系统变为“blocked”状态；
3）拥有锁的线程调用锁的release()方法来释放锁，这样锁就会进入“unlocked”状态；
4）“blocked”状态的线程就会收到一个通知，并有权利获得锁。如果多个线程处于“blocked”状态，所有线程都会先解除“blocked”状态，然后系统选择一个线程来获得锁，其他的线程继续沉默（“blocked”）。
这样一个锁机制存在的问题是，当一个线程获得了锁之后没有释放，又申请了同一个锁资源，此时该线程会进入blocked状态，而且形成死锁。threading.RLock锁原语解决了该问题。RLock对象允许一个线程多次对其进行acquire操作，因为在其内部通过一个counter变量维护着线程acquire的次数。而且每一次的acquire操作必须有一个release操作与之对应，在所有的release操作完成之后，别的线程才能申请该RLock对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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):
#num作为共享资源
global num
while True:
#把共享资源的处理放在acquire()和release()之间
mylock.acquire()
print 'Thread(%s) locked, Number: %d\n'%(self.t_name, num)
if num>=4:
mylock.release()
print 'Thread(%s) released, Number: %d\n'%(self.t_name, num)
break
num+=1
print 'Thread(%s) released, Number: %d\n'%(self.t_name, num)
mylock.release()
def test():
t1 = myThread('t1')
t2 = myThread('t2')
t1.start()
t2.start()
if __name__== '__main__':
test()
2、条件同步——生产者和消费者问题
当某些条件下才会出现资源竞争的时候就会涉及条件同步。一个形象一点的例子是，伊利牛奶生产厂家可以生产好多牛奶，并将它们放在多个好又多分店进行销售，小明可以从任一间好又多分店中购买到牛奶。只有当厂家把牛奶放在某一分店里，小明才可以从这间分店中买到牛奶。看一下代码描述：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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
据说可以用队列的FIFO特性来实现生产者和消费者问题，后续再学习。
页:
[1]