Python之多线程：线程互斥与线程同步

一、锁在多线程中的使用：线程互斥

lock = threading.Lock()#创建一个锁对象

1、with lock:

pass

和进程使用的方式相同

 

2、控制线程结束的时间

通过一个全局变量

# encoding=utf-8

import threading,time,Queue,random

 

exitFlag = False

def write(lock,queue):

while exitFlag != True:

with lock:

data = random.randint(1,100)

print 'put:',data

queue.put(data)

time.sleep(1)

 

def read(queue):

while exitFlag != True:

print 'get:',queue.get()

time.sleep(1)

 

if __name__ == '__main__':

lock = threading.Lock()

queue = Queue.Queue()

t1 = threading.Thread(target=write,args=(lock,queue))

t2 = threading.Thread(target=write,args=(lock,queue))

t3 = threading.Thread(target=read,args=(queue,))

t1.start()

t2.start()

t3.start()

time.sleep(10)

exitFlag = True

t1.join()

t2.join()

t3.join()

 

二、线程同步

1、生产者--消费者模式

Queue() 作为生产者和消费者的中介

from

 

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 xrange(5):

print '%s:%s is producing %d to the queue\n'%(time.ctime(),self.getname(),i)

self.data.put(i)

time.sleep(2)

print '%s:%s put finished \n'%(time.ctime(),self.getname(),i)

def 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 xrange(5):

val=self.data.get()

print '%s:%s is consumer %d in the queue\n'%(time.ctime(),self.getname(),val)

print '%s:%s consumer finished \n'%(time.ctime(),self.getname(),i)

 

if __name=='__main__':

queue=Queue()#没有制定队列大小，默认为无限大，可以不受限制的放入队列

producer=Producer('Pro',queue)

consumer=Consumer('Con',queue)

producer.start()

time.sleep(1)

consumer.start()

producer.join()

consumer.join()

print 'mainThread end'

 

2、Event 信号传递

event=threading.Event()

import threading,time,Queue,random

 

def write(lock,queue,event):

while not event.isSet():

with lock:

thread = threading.currentThread()

data = random.randint(1,100)

print 'this is thread:',thread.getName(),'put:',data

queue.put(data)

time.sleep(1)

 

def read(queue):

while not event.isSet():

print 'get:',queue.get()

time.sleep(1)

 

if __name__ == '__main__':

lock = threading.Lock()

queue = Queue.Queue()

event=threading.Event()

t1 = threading.Thread(target=write,args=(lock,queue,event))

t2 = threading.Thread(target=write,args=(lock,queue,event))

t3 = threading.Thread(target=read,args=(queue,))

t1.start()

t2.start()

t3.start()

time.sleep(10)

event.set()

t1.join()

t2.join()

t3.join()

3、lock :只能加一把锁

4、semaphore：可以加多把锁

设置限制最多3个线程同时访问共享资源：s = threading.Semaphore(3)

5、event:线程等待某一时间的发生，之后执行逻辑

6、Condition 条件

con=threading.Condition()

使用场景：处理复杂的逻辑。基于锁来实现的

两个线程之间做一些精准的通信

线程A做了某一件事，中途需要停止

线程B做另外一件事情，线程B通知线程A

线程A继续

（1）额外提供了wait()方法和notify()方法，用于处理复杂的逻辑

（2）wait()释放锁，并且等待通知

（3）Notify（）唤醒对方，可以继续下去。但是需要两个线程之间需要抢锁，谁抢到执行谁

通过（2）和（3），实现线程间的通信。

import threading

import time

product = 0

exitFlag = False

def consumer(con):

global product

while exitFlag != True:

with con:

print 'enter consummer thread'

if product == 0:

con.wait()

else:

print 'now consummer 1 product'

product -= 1

print 'after consummer, we have ',product,'product now'

time.sleep(2)

 

def producer(con):

global product

while exitFlag != True:

with con:

print 'enter producer thread'

product += 1

con.notify()

print 'after producer, we have ', product, 'product now'

time.sleep(2)

 

if __name__ == '__main__':

con = threading.Condition()

c1 = threading.Thread(target=consumer,args=(con,))

p1 = threading.Thread(target=producer, args=(con,))

 

c1.start()

p1.start()

time.sleep(6)

exitFlag = True

c1.join()

p1.join()

 

7、死锁

t1:拥有lock1锁，申请lock2锁

t2:拥有lock2锁，申请lock1锁

（1）如何尽量的保证不出现死锁：

定义锁的使用顺序