Java使用Condition唤醒指定线程

使用ReentrantLock实现同步

首先创建一个功能类，用于实现线程的功能

public class MyService {
	private Lock lock = new ReentrantLock();
	public void methodA() {
		try {
			lock.lock();  //加锁，作用相当于synchronized
			
			System.out.println(Thread.currentThread().getName()+" 进入methodA  并得到锁");
			
			Thread.sleep(2000);
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+" 离开methodA  并释放锁");
			lock.unlock(); //释放锁
		}
		
	}
	
	public void methodB() {
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName()+" 进入methodB  并得到锁");
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			System.out.println(Thread.currentThread().getName()+" 离开methodB  并释放锁");
			lock.unlock();
		}
		
	}
}

创建的四个线程，两个运行methodA，两个运行methodB

public static void main(String[] args) {
		final MyService service = new MyService();
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				service.methodA();
			}

		}).start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				service.methodA();
			}

		}).start();
		
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				service.methodB();
			}

		}).start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				service.methodB();
			}

		}).start();

	}

运行结果：

Thread-0 进入methodA  并得到锁
Thread-0 离开methodA  并释放锁
Thread-1 进入methodA  并得到锁
Thread-1 离开methodA  并释放锁
Thread-2 进入methodB  并得到锁
Thread-2 离开methodB  并释放锁
Thread-3 进入methodB  并得到锁
Thread-3 离开methodB  并释放锁

目前来看，lock和unlock之间是被锁定的，这一点和关键字synchronized作用相同

使用Condition唤醒指定线程

synchronized关键字与wait（）和notify（）/notifyAll（）结合能够实现等待通知模型，但是却面临一个问题，就是，被wait（）唤醒的线程是随机的，而notifyAll（）唤醒的又是所有的，不能唤醒指定的线程。

ReentrantLock借助于Condition就可以实现唤醒指定线程，这样在线程调度上更加灵活。

public class MyService {
	private Lock lock = new ReentrantLock();
	private Condition condition  = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	public void await1() {
		try {
			lock.lock();
			System.out.println("执行 await1 方法");
			condition.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
			System.out.println("await1 锁释放了");
		}
	}
	
	public void await2() {
		try {
			lock.lock();
			System.out.println("执行 await2 方法");
			condition2.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
			System.out.println("await2锁释放了");
		}
	}
	
	public void signal1() {
		try {
			lock.lock();
			System.out.println("执行signal1方法");
			condition.signal();
			System.out.println("通知了await1 ");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
			
		}
	}
	
	public void signal2() {
		try {
			lock.lock();
			System.out.println("执行signal2方法");
			condition2.signal();
			System.out.println("通知了await2 ");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
			
		}
	}
}

四个线程类

public class ThreadA extends Thread{
	private MyService service;
	public ThreadA(MyService service) {
		this.service = service;
	}
	
	public void run() {
		service.await1();
	}
}

public class ThreadAA extends Thread{
	private MyService service;
	public ThreadAA(MyService service) {
		this.service = service;
	}
	
	public void run() {
		service.await2();
	}
}

ThreadB用于唤醒由condition等待的线程

public class ThreadB extends Thread{
	private MyService service;
	public ThreadB(MyService service) {
		this.service = service;
	}
	
	public void run() {
		service.signal1();
	}
}

threadBB用于唤醒由condition2等待的线程

public class ThreadBB extends Thread {
	private MyService service;
	public ThreadBB(MyService service) {
		this.service = service;
	}
	
	public void run() {
		service.signal2();
	}
}

public static void main(String[] args) {
	MyService service = new MyService();
	ThreadA threadA = new ThreadA(service);
	ThreadAA threadAA = new ThreadAA(service);
	ThreadB threadB = new ThreadB(service);
	ThreadBB threadBB = new ThreadBB(service);
	
	try {
		threadA.start();
		threadAA.start();
		Thread.sleep(300);
		threadB.start();
		ThreadA.sleep(3000);
		threadBB.start();
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

运行结果：

执行 await1 方法
执行 await2 方法
执行signal1方法    //threadB只唤醒了由condition等待的线程
通知了await1 
await1 锁释放了
执行signal2方法
通知了await2 
await2锁释放了