java ReentrantLock Condition调试记录

今天看了多线程使用Lock和Condition

package com.cmb.firmbank.baseFrame.socket;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class X {
	private final ReentrantLock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	public void m(int i) {
		System.out.println("m start!");
		lock.lock(); // block until condition holds
		try {
			System.out.println("try catch!");
		} finally {
			lock.unlock();
		}
		System.out.println("m end!");
	}
	public static void main(String[] args) {
		X x = new X();
		T1 t1 = new T1(x);
		T2 t2 = new T2(x);
		t1.start();
		t2.start();
	}
	
}
class T1 extends Thread{
	private X x ;
	public T1(X x) {
		this.x = x;
	}
	@Override
	public void run() {
		x.m(0);
	}
}
class T2 extends Thread{
	private X x ;
	public T2(X x) {
		this.x = x;
	}
	@Override
	public void run() {
		x.m(1);
	}
}

 一个线程进入lock里面，另外一个现场就无法进入lock，直到lock的线程unlock之后，第二个线程才能进入。

 

使用condition

package com.cmb.firmbank.baseFrame.socket;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class X {
	private final ReentrantLock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	public void m(int i) {
		System.out.println("m start!");
		lock.lock(); // block until condition holds
		try {
			// ... method body
			if(i==0){
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else if(i==1){
				condition.signal();
			}
			System.out.println("try catch!");
		} finally {
			lock.unlock();
		}
		System.out.println("m end!");
	}
	public static void main(String[] args) {
		X x = new X();
		T1 t1 = new T1(x);
		T2 t2 = new T2(x);
		t1.start();
		t2.start();
	}
	
}
class T1 extends Thread{
	private X x ;
	public T1(X x) {
		this.x = x;
	}
	@Override
	public void run() {
		x.m(0);
	}
}
class T2 extends Thread{
	private X x ;
	public T2(X x) {
		this.x = x;
	}
	@Override
	public void run() {
		x.m(1);
	}
}

 当一个线程进入lock里面，未到condition.await()时，第二个线程无法进入lock里面，但是当第一个线程进入await等待时，第二个线程可以进入lock，直到第二个线程进入unlock后，第一个线程才从await往下走。

 

 

总结：

1、如果不使用condition,多个线程中只有一个能进入lock逻辑里面。

2、如果在lock中使用await，当前线程会等待，其他等待线程进入lock，当前线程直到其他线程的siginal之后，才继续往下走。

 

留此文便查

 

评论

2 楼 smallbee 2013-10-23  

xin_jmail 写道

首先感谢楼主的文章，让我知道了lock.newCondition()的用法。实验完，发现Condition的await()、signal()、signalAll()方法和wait()、notify()、notifyAll()方法作用类似。

最后关于第二个使用 Condition例子，发表下我的观点。
如果线程1先于线程0运行，那么线程1运行condition.signal()语句后，由于目前线程0还没有进入await(),所以不会“激活”任何线程。待线程1释放锁后，当线程0运行时，运行await()方法，就一直等待别的线程激活。结果因线程1已运行完，线程0就一直等待，程序“卡死”。

确实存在你说的问题，我们项目的场景可能和你说的不一样，对于线程1会循环处理。

1 楼 xin_jmail 2013-10-11  

首先感谢楼主的文章，让我知道了lock.newCondition()的用法。实验完，发现Condition的await()、signal()、signalAll()方法和wait()、notify()、notifyAll()方法作用类似。

最后关于第二个使用 Condition例子，发表下我的观点。
如果线程1先于线程0运行，那么线程1运行condition.signal()语句后，由于目前线程0还没有进入await(),所以不会“激活”任何线程。待线程1释放锁后，当线程0运行时，运行await()方法，就一直等待别的线程激活。结果因线程1已运行完，线程0就一直等待，程序“卡死”。