JAVA多线程-Lock的使用（一）-ReentrantLock与Condition

JAVA多线程-Lock的使用

      本节主要介绍使用Java5中的Lock对象也能实现同步的效果，而且在使用上更加方便。

一、使用ReentrantLock类

     在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定 ，多路分支通知等功能，并且在使用上也比synchronized更加的灵活。

     1.1 使用ReentrantLock实现同步：测试

package org.jksoft.thread.reentrantLock;

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

/**
 * 测试一：使用ReentrantLock去实习线程间的同步
 * @author mcl
 *
 * 2016-2-21-上午11:11:46
 */
public class Test1 {
	public static void main(String[] args) {
		MyService service = new MyService();
		for(int i =0;i<10;i++){
			new ThreadA(service).start();
		}
	}
}
class ThreadA extends Thread{
	private MyService service;
	public ThreadA(MyService service){
		this.service = service;
	}
	public void run(){
		service.print();
	}
}
class MyService{
	private Lock lock = new ReentrantLock();
	public void print(){
		//获取锁
		lock.lock();
		for(int i=0;i<5;i++){
			System.out.println(Thread.currentThread().getName()+" : "+(i+1));
		}
		//释放锁
		lock.unlock();
	}
}

    结果： 

   

  分析： 我们可以看到，每个线程都是等待上一个线程打印完毕之后，才继续打印，因为当前线程已经持有锁，但线程之间打印的顺序是随机的。

  1.2 使用condition去实现等待/通知

package org.jksoft.thread.reentrantLock;

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

/**
 * 测试二：使用condition实现等待/通知 注意：wait与notify都是需要在同步代码块中调用，也就是必须持有当前锁
 * 所以condition中的await()与signal()也同样必须持有当前锁
 * 
 * @author mcl
 * 
 *         2016-2-21-上午11:11:46
 */
public class Test2 {
	public static void main(String[] args) {
		MyService2 service = new MyService2();
		ThreadB thread = new ThreadB(service );
		thread.start();
		try {
			Thread.sleep(3000);
			service.signal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
class ThreadB extends Thread{
	private MyService2 service;
	public ThreadB(MyService2 service){
		this.service = service;
	}
	public void run(){
		service.await();
	}
}
class MyService2 {
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void await() {
		try {
			lock.lock();
			System.out.println("A");
			condition.await();
			System.out.println("B");

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
			System.out.println("锁被释放了");
		}
	}
	public void signal(){
		try {
			lock.lock();
			condition.signal();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

    结果: 线程B先执行await()等待通知，主线程睡3s后，调用service的signal()方法，唤醒处于waiting状态的线程B。

1.3 使用多个condition实现通知部分线程：

package org.jksoft.thread.reentrantLock;

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

/**
 * 测试三：使用多个condition实现线程部分通知
 * 
 * @author mcl
 * 
 *         2016-2-21-上午11:11:46
 */
public class Test3 {
	public static void main(String[] args) {
		MyService3 service = new MyService3();
		ThreadC thread = new ThreadC(service );
		thread.start();
		ThreadD thread2 = new ThreadD(service );
		thread2.start();
		try {
			Thread.sleep(3000);
			service.Asignal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
class ThreadC extends Thread{
	private MyService3 service;
	public ThreadC(MyService3 service){
		this.service = service;
	}
	public void run(){
		service.Aawait();
	}
}
class ThreadD extends Thread{
	private MyService3 service;
	public ThreadD(MyService3 service){
		this.service = service;
	}
	public void run(){
		service.Bawait();
	}
}
class MyService3 {
	private Lock lock = new ReentrantLock();
	private Condition conditionA = lock.newCondition();
	private Condition conditionB = lock.newCondition();
	public void Aawait() {
		try {
			lock.lock();
			System.out.println("C...等待");
			conditionA.await();
			System.out.println("C...被唤醒");

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void Bawait() {
		try {
			lock.lock();
			System.out.println("D...等待");
			conditionA.await();
			System.out.println("D...被唤醒");

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
			System.out.println("锁被释放了");
		}
	}
	public void Asignal(){
		try {
			lock.lock();
			conditionA.signal();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void Bsignal(){
		try {
			lock.lock();
			conditionB.signal();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

     运行结果：  线程C（基于conditionA）和线程D（基于conditionB）都存于等待状态，主线程在3s后，利用conditionA唤醒了线程C，而线程D依旧处于等待状态，这也就达到了我们利用多个condition去部分通知等待线程。