不可重入锁、可重入锁的实现以及测试

可重入锁定义：线程去请求自己拥有的锁可请求到

interface SelfDefineLock{
	void lock();
	void unlock();
}

class Father{
	SelfDefineLock lock;
	Father(SelfDefineLock lock){
		this.lock = lock;
	}
	void do_(){
		lock.lock();
		System.out.println("Father Class " + "Thread " + Thread.currentThread().getName());
		lock.unlock();
	}
}

class Child extends Father{
	Child(SelfDefineLock lock) {
		super(lock);
		// TODO Auto-generated constructor stub
	}
	void do_(){
		lock.lock();
		System.out.println("Child Class " + "Thread " + Thread.currentThread().getName());
		super.do_();
		lock.unlock();
	}
}

class NoRtLock implements SelfDefineLock{
//	private volatile boolean locked = false;
	private boolean locked = false;
	public synchronized void lock(){
		while(locked){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		locked = true;
	}
	public synchronized void unlock(){
		locked = false;
		notify();
	}
}

class RtLock implements SelfDefineLock{
	private volatile boolean locked = false;
	Thread locked_by = null;
	int locked_cnt = 0;
	
	public synchronized void lock(){
		Thread current_thread = Thread.currentThread();
		while(locked && current_thread != locked_by){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		locked = true;
		locked_by = current_thread;
		++locked_cnt;
	}
	
	public synchronized void unlock(){
		--locked_cnt;
		if(locked_cnt == 0){
			locked = false;
			notify();
		}
	}
}

public class Test {
	static void test_nortlock(){
		SelfDefineLock lock = new NoRtLock(); 
		final Father instance = new Child(lock);
		new Thread(){
			public void run(){
				instance.do_();
			}
		}.start();
	}
	static void test_rtlock(){
		SelfDefineLock lock = new RtLock(); 
		final Father instance = new Child(lock);
		new Thread(){
			public void run(){
				instance.do_();
			}
		}.start();
	}
	public static void main(String[] args){
		test_nortlock();
		test_rtlock();
	}
}

上面RtLock是可重入锁，NoRtLock是不可重入锁，运行结果如下：

Child Class Thread Thread-0
Child Class Thread Thread-1

Father Class Thread Thread-1

不可重入锁发生了死锁，调用

super.do_();

执行到父类函数

void do_(){
		lock.lock();
		System.out.println("Father Class " + "Thread " + Thread.currentThread().getName());
		lock.unlock();
	}

时无法获取锁，阻塞在

lock.lock();

上面代码需要注意的地方:wait() notify() notifyAll()方法需要由同步监视器调用，两个Lock代码中都加入了synchronized代码块，因此内部能够使用wait()。原本是打算不用synchronized的，而使用volatile修饰locked变量保证现场安全，但是那样就不用使用wait()等了。另一种办法使用wait()的办法是用Condition类来帮忙，添加隐式同步监视器。<<Java疯狂讲义>>中有。Condition cond = Lock.newCondition()...

博客没教材系统，多看书比较靠谱，书上可能代码少了些