java并发编程(十二): 显示锁

显示锁：

Lock与ReentrantLock:

• Lock接口

void lock(); //获取锁
void lockInterruptibly() throws InterruptedException; //获取锁，且当前线程可被中断
boolean tryLock(); //尝试获取锁，true获取到锁, false未获取到锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock(); //释放锁
Condition newCondition(); //在当前锁上创建一个等待条件

• Lock的标准用法

Lock lock = new ReentrantLock();
		
lock.lock();
try{
	// to do sth.
} finally{
	lock.unlock(); //须要在finally中释放锁
}

轮询锁与定时锁：

• 轮询锁和定时锁可由tryLock来实现。

• 轮询锁,定时锁可以避免死锁的发生。

• 由tryLock实现轮询锁

public boolean transferMoney(Account fromAcct,
				 Account toAcct,
			        int amount,
				 long timeout,
				 TimeUnit unit){
	long fixedDelay = getFixedDelayComponentNanos(timeout, unit);
	long randMod = getRandomDelayModulusNanos(timeout, unit);
	long stopTime = System.nanoTime() + unit.toNanos(timeout);
		
	while (true){
		if (fromAcct.lock.tryLock()){ //若获取到源账户锁
			try{
				if (toAcct.lock.tryLock()){ //若获取到目的账户锁
					try{
						if (fromAcct.getBalance() < amount){
							throw new RuntimeException("money.not.enough");
						} else{
							fromAcct.debit(amount);
							toAcct.credit(amount);
							return true;
						}
					} finally{
						toAcct.lock.unlock();
					}
				}
			} finally{
				fromAcct.lock.unlock();
			}
		}
		if (System.nanoTime() < stopTime){
			return false;
		}
		try {
			Thread.sleep(fixedDelay + rand.nextLong()%randMod);
		} catch (InterruptedException e) {
				
		}
	}
}

你也可以采用定时实现：

lock.tryLock(timeout, unit);

可中断的锁获取操作：

lock.lockInterruptibly();
try{
	// maybe throws InterruptedException
	doSomething();
} finally{
	lock.unlock();
}

非块结构的加锁：

• 如ConcurrentHashMap中的分段锁实现。

性能考虑因素：

• 上图是对HashMap的测试，可见在jdk1.5时ReentrantLock比内置锁吞吐量高，jdk1.6差异就很小了。

• 性能是一个不断变化的指标，如果在昨天的测试中发现X比Y更快，那么在今天就可能已经过时了。

公平性：

• ReentrantLock可初始化为公平或非公平的锁。

• 大多数情况下非公平锁的性能高于公平锁的性能。

• 基于公平锁，非公平锁及ConcurrentHashMap对HashMap进行吞吐量测试。

• 当持有锁的时间相对较长，或者请求锁的平均时间间隔较长，那么应该使用公平锁。

在Synchronized和ReentrantLock之间作出选择：

• 在一些内置锁无法满足需求的情况下，ReentrantLock可以作为一种高级工具。当需要一些高级功能时才应该使用ReentrantLock,这些功能包括：可定时，可轮询，可中断，公平队列，及非块结构的锁。否则还是应该优先使用synchronized.

读--写锁：

//读写锁允许同时多个线程读, 或最多一个线程写
public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

• 读写锁的可选实现：

       1. 释放优先。当写入锁释放后，应该优先选择读线程，写线程，还是最先发出请求的线程?

       2. 读线程插队。锁由读线程持有，写线程再等待，再来一个读线程，是继续让读线程访问，还是让写线程访问.

       3. 重入性。读取锁和写入锁是否可重入?

       4. 降级。将写入锁降级为读取锁。

       5. 升级。将读取锁升级为写入锁。

• 当锁的持有时间较长并且大部分操作都不会修改被守护的资源时，可用读写锁提高并发性。

/**
 * 读写锁来包装Map
 */
public class ReadWriteMap<K, V> {
	private final Map<K, V> map;
	private final ReadWriteLock lock = new ReentrantReadWriteLock();
	private final Lock r = lock.readLock();
	private final Lock w = lock.writeLock();
	
	public ReadWriteMap(Map<K, V> map){
		this.map = map;
	}
	
	// 其他写操作...
	
	public V put(K key, V value){
		w.lock(); //请求写锁
		try{
			return map.put(key, value);
		} finally{
			w.unlock(); //勿忘
		}
	}
	
	// 其他读操作...
	
	public V get(K key){
		r.lock(); //请求读锁
		try{
			return map.get(key);
		} finally{
			r.unlock(); //勿忘
		}
	}
}

• 对ArrayList使用ReentrantLock和ReadWriteLock测试吞吐量。

不吝指正。