Java并发编程：Lock

Java并发编程：Lock 

一.Lock

实现提供了比使用 synchronized 方法和语句更灵活、更具可伸缩性的锁定机制，可以支持多个相关的 Condition 对象。

 

 Lock&synchronized用途比较

基本语法上，ReentrantLock与synchronized很相似，它们都具备一样的线程重入特性，只是代码写法上有点区别而已，一个表现为API层面的互斥锁(Lock)，一个表现为原生语法层面的互斥锁(synchronized)。ReentrantLock相对synchronized而言还是增加了一些高级功能，主要有以下三项：

1.等待可中断：当持有锁的线程长期不释放锁时，正在等待的线程可以选择放弃等待，改为处理其他事情，它对处理执行时间非常上的同步块很有帮助。而在等待由synchronized产生的互斥锁时，会一直阻塞，是不能被中断的。

 

2.可实现公平锁：多个线程在等待同一个锁时，必须按照申请锁的时间顺序排队等待，而非公平锁则不保证这点，在锁释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁时非公平锁，ReentrantLock默认情况下也是非公平锁，但可以通过构造方法ReentrantLock（ture）来要求使用公平锁。

 

3.锁可以绑定多个条件：ReentrantLock对象可以同时绑定多个Condition对象(条件变量或条件队列)，而在synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含条件，但如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而ReentrantLock则无需这么做，只需要多次调用newCondition()方法即可。而且我们还可以通过绑定Condition对象来判断当前线程通知的是哪些线程(即与Condition对象绑定在一起的其他线程)。

    

 实现类：ReentrantLock(可重入互斥锁)、 ReentrantReadWriteLock.ReadLock、 ReentrantReadWriteLock.WriteLock

 Lock的简单的使用：

Lock lock = new ReentrantLock();//默认使用非公平锁，如果要使用公平锁，需要传入参数true  

lock.lock();  
try {  
    //To doSomething
 } catch(Exception e){
		 	
 } finally {  		//一定在finally块中释放锁，如果锁中的代码将抛出异常，锁就有可能永远得不到释放。
	 lock.unlock();        
}

 

 

二.Lock&Condition(执行条件)

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法

常用方法：await()和signal()方法

 

例子：用Lock Condition改写上一个程序程序：子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次。

 

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

public class ConditionCommunication {

	public static void main(String[] args) {

		final Business bussiness = new Business();
		new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			bussiness.main(i);
		}
	}

	static class Business {
		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		private boolean bShouldSub = true;

		public void sub(int i) {
			lock.lock();
			try {
				while (!bShouldSub) { // 防止虚假唤醒
					try {
						condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

				for (int j = 1; j <= 10; j++) {
					System.out.println("sub thread sequence of " + j
							+ ", loop of " + i);
				}
				bShouldSub = false;
				condition.signal();

			} finally {
				lock.unlock();
			}
		}

		public void main(int i) {
			lock.lock();
			try {
				while (bShouldSub) {
					try {
						condition.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 100; j++) {
					System.out.println("main thread sequence of " + j
							+ ", loop of " + i);
				}
				bShouldSub = true;
				condition.signal();

			} finally {
				lock.unlock();
			}
		}
	}
}

可以参照Condition的Api中有个阻塞队列的实例

 

需要注意Condition中的是await()方法，  不是从Object继承的wait() （用错不报错）。

 

另一个例子：

/*
	主线程循环100，子线程1循环10次,子线程2循环20次
	接着又回到主线程循环100次，接着再回到子线程1.....，如此循环50次，请写出程序。 

 */

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

public class ThreeConditionCommunication {

	public static void main(String[] args) {

		final Business bussiness = new Business();
		new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub2(i);
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <= 50; i++) {
					bussiness.sub3(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			bussiness.main(i);
		}
	}
	
	static class Business {
		Lock lock = new ReentrantLock();
		Condition condition1 = lock.newCondition();
		Condition condition2 = lock.newCondition();
		Condition condition3 = lock.newCondition();
		private int ShouldSub = 1;

		public void sub2(int i) {
			lock.lock();
			try{
				while (ShouldSub != 2) {   //防止虚假唤醒
					try {
						condition2.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
				for (int j = 1; j <= 10; j++) {
					System.out.println("sub2 thread sequence of " + j + ", loop of " + i);
				}
				ShouldSub = 3;
				condition3.signal();
				
			}finally {
				lock.unlock();
			}
		}

		public void sub3(int i) {
			lock.lock();
			try{
				while (ShouldSub != 3) {   //防止虚假唤醒
					try {
						condition3.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
				for (int j = 1; j <= 20; j++) {
					System.out.println("sub3 thread sequence of " + j + ", loop of " + i);
				}
				ShouldSub = 1;
				condition1.signal();
				
			}finally {
				lock.unlock();
			}
		}
	
		public void main(int i) {
			lock.lock();
			try{
				while (ShouldSub != 1) {
					try{
						condition1.await();
					} catch(InterruptedException e) {
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 100; j++) {
					System.out.println("main thread sequence of " + j + ", loop of "+ i);
				}
				ShouldSub = 2;
				condition2.signal();
			
			}finally{
				lock.unlock();
			}
		}
	}
}

 

三.读写锁

    读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

　正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

 

　可以通过readLock()获取读锁，通过writeLock()获取写锁。

 例子：读写锁，创建3个线程用来读 ， 3个线程用来写

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {

	public static void main(String[] args) {
		final Queue que = new Queue();
		for (int i = 0; i < 3; i++) {

			new Thread(new Runnable() {
				public void run() {
					while (true) {
						que.get();
					}
				}
			}).start();

			new Thread(new Runnable() {
				public void run() {
					while (true) {
						que.put(new Random().nextInt(10000));
					}
				}
			}).start();

		}
	}
}

class Queue {
	private Object data = null; // 需要读写的对象
	ReadWriteLock rwl = new ReentrantReadWriteLock();

	public void get() {
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()
					+ " is ready to get data!");
			Thread.sleep(new Random().nextInt(1000));
			System.out.println(Thread.currentThread().getName()
					+ " hava read data: " + data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwl.readLock().unlock();
		}
	}

	public void put(Object data) {
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()
					+ " is ready to put data!");
			Thread.sleep((long) Math.random() * 1000);
			this.data = data;
			System.out.println(Thread.currentThread().getName()
					+ " have write data " + data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwl.writeLock().unlock();
		}
	}

}

 

总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

        2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

        3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

       4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

       5）Lock可以提高多个线程进行读操作的效率。

 

当需要以下高级特性时，才应该使用：可定时的、可轮询的与可中断的锁获取操作，公平队列，或者非块结构的锁。否则，请使用synchronized。