JDK5新特性之线程锁技术（二）

一. Lock实现线程同步互斥

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也是一个对象。

两个线程执行的代码片段要实现同步互斥的效果，他们必须用同一个Lock对象。锁是上在代表要操作的资源的类的内部方法中，

而不是线程代码中。

public class LockTest {

	public static void main(String[] args) {
		new LockTest().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();

		// 线程1
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
						outputer.output("1111111111");
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}).start();

		// 线程2
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
						outputer.output("2222222222");
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}

	class Outputer {
		private Lock lock = new ReentrantLock();
		public void output(String name) {
			lock.lock(); // 加锁
			try {
				for (int i = 0; i < name.length(); i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			} finally {
				lock.unlock(); // 释放锁
			}
		}
	}
}

二. 读写锁实现线程同步互斥

读写锁分为读锁和写锁，多个读锁不互斥，读锁和写锁互斥，写锁与写锁互斥，这是由JVM自己控制的，我们只要上好相应的锁即可。

如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码要修改数据，那只能有一个人在写，且不能同时读取，那就上写锁。总之：读的时候上读锁，写的时候上写锁

/**
 * 读写锁的案例
 */
public class ReadWriteLockTest {

	public static void main(String[] args) {
		final Queues queues = new Queues();

		// 开启3个读的线程和3个写的线程
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					while (true) {
						queues.get();  // 调用读数据的方法
					}
				}
			}.start();

			new Thread() {
				public void run() {
					while (true) {
						queues.put(new Random().nextInt(10000)); // 调用写数据的方法
					}
				}
			}.start();
		}
	}
}

class Queues {
	private Object data = null; // 共享数据, 只能有一个线程写数据，但能有多个线程同时读数据
	private ReadWriteLock rwl = new ReentrantReadWriteLock();

	// 读的方法：用的是读锁readLock()
	public void get() {
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + " get ready to read data！");
			Thread.sleep((long) Math.random() * 1000);
			System.out.println(Thread.currentThread().getName() + " have read data:" + data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwl.readLock().unlock();
		}
	}

	// 写的方法：用的是写锁writeLock()
	public void put(Object data) {
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + " get ready to write 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();
		}
	}
}

注意：释放锁的代码一定要放在finally里面，防止出现不可预知的异常的时候无法释放资源。

三. 读写锁的典型应用

/**
 * 缓存的简单实现
 */
public class CacheDemo {  

    private Map<String, Object> cache = new HashMap<String, Object>();  

    private ReadWriteLock rwl = new ReentrantReadWriteLock();  

    public Object getData(String key) {
        // 用户来读取value数据，则在进入程序后上读锁
        rwl.readLock().lock();
        Object value = null;
        try {
            value = cache.get(key);
            if (value == null) {
                // 读到的值为空则释放读锁，打开写锁，准备给value赋值
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try {
                    // 打开写锁还为空，则给value赋值xxx
                    if (value == null) {
                        value = "xxx";  // 实际应该去数据库中查询 queryDB()
                        cache.put(key, value);
                    }
                } finally {
                    // 使用完写锁后关掉
                    rwl.writeLock().unlock();
                }
                // 释放写锁后，恢复读锁
                rwl.readLock().lock();
            }
        } finally {
            // 用户读完后释放掉读锁
            rwl.readLock().unlock();
        }
        return value;
    }
}