多线程算法学习一LockOne和LockTwo(python实现)

多线程算法学习一LockOne和LockTwo

需要用到的单元

import time
import threading

Lockone算法

LockOne算法是加自己的锁，等待对方解锁，所以如果不出现两个对象同时在wait前执行write。就完全没有问题。

经测试，双方等待死锁的情况极大。

class lockone:
	def __init__(self):
		self.flag = []
		self.flag.append( False )
		self.flag.append( False )
	def lock(self,id):
		i = id
		j = 1 -i
		self.flag[i] = True
		print "wait = %s" % (id) 
		while ( self.flag[j] ):
			pass
		print "unlock = %s " % (id)
	def unlock(self,id):
		i = id 
		self.flag[i] = False

LockTwo算法

此算法，从测试结果来看，是可以达到互斥的关系的。

测试数据如下

但如果到程序开始只跑了一个线程，或者程序结束的时候两个线程没有结束，必然进入死锁。

class locktwo:
	def __init(self):
		self.vic = 0
	def lock(self,id):
		i = id
		self.vic = i
		if (self.vic == i) :
			print "wait = %s" % (id)
		while(self.vic == i) :
			pass
		print "unlock = %s " % (id)
	def unlock(self,id):
		pass

全局变量

temp = 0
locks = locktwo()

主程序

class threadtest(threading.Thread):
	def __init__(self,name):
		threading.Thread.__init__(self)
		self.id = name
	def run(self):
		global temp
		while(True):
			if temp >=100:
				self.thread_stop = True
				break
			else:
				print "temp = %s id = %s ",(temp,self.id)
			locks.lock( self.getid() )
			try:
				temp = temp+1
				print "ok id = %s : value =  %d " % (self.id , temp)
			finally:
				locks.unlock(self.getid())
			
	def getid(self):
		return self.id

if __name__ == "__main__":
	thread1 = threadtest(0)
	thread2 = threadtest(1)
	
	thread1.start()
	thread2.start()

两者都是不完美的双线程锁算法。

不过两者集合的Peterson锁，完美的实现了一个双线程锁算法。

注：

本文算法来自《多处理器编程的艺术》 英文版  <The Art of Multiprocessor Programming>