Android多线程研究（九）——线程锁Lock

在前面我们在解决线程同步问题的时候使用了synchronized关键字，今天我们来看看Java 5.0以后提供的线程锁Lock.

Lock接口的实现类提供了比使用synchronized关键字更加灵活和广泛的锁定对象操作，而且是以面向对象的方式进行对象加锁。

		@Override		public void run() {			while(true){				Lock lock = new ReentrantLock();				try {					lock.lock();					Thread.sleep(new Random().nextInt(3000));					String data = readData();					System.out.print("读取数据: " + data);				} catch (InterruptedException e) {					e.printStackTrace();				}finally{					lock.unlock();				}			}		}

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的。

import java.util.Random;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockTest {	static ReadWriteLock rwl = new ReentrantReadWriteLock();		private static String data = null;	public static void main(String[] args) {		Runnable runnable1 = new MyRunnable1();		Runnable runnable2 = new MyRunnable2();		for(int i=0; i<3; i++){			new Thread(runnable1).start();			new Thread(runnable2).start();		}	}		static class MyRunnable1 implements Runnable{				@Override		public void run() {			writeData("" + new Random().nextInt(100));			}	}		static class MyRunnable2 implements Runnable{		@Override		public void run() {			readData();				}	}		private static void writeData(String var){		rwl.writeLock().lock();		try {			System.out.println(Thread.currentThread().getName() + " 准备写");			Thread.sleep(new Random().nextInt(3000));			data = var;			System.out.println(Thread.currentThread().getName() + " 写完毕");		} catch (InterruptedException e) {			e.printStackTrace();		}finally{			rwl.writeLock().unlock();		}			}		private static void readData(){		rwl.readLock().lock();  //用读锁锁住		try {			System.out.println(Thread.currentThread().getName() + " 准备读");			Thread.sleep(new Random().nextInt(3000));			System.out.println(Thread.currentThread().getName() + " 读完毕");		} catch (InterruptedException e) {			e.printStackTrace();		}finally{			rwl.readLock().unlock();		}	}}

用过Hibernate框架的朋友可能知道，Hibernate查询数据库有缓存机制，如果某个数据在内存中存在则可以并发的去读取，如果缓存中没有数据则需要互斥的去从数据库取数据。

import java.util.HashMap;import java.util.Map;import java.util.concurrent.locks.ReentrantReadWriteLock;public class CacheDemo {	private Map<String, Object> cache = new HashMap<String, Object>();	public static void main(String[] args) {			}		private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();	/**	 * 实现多个并发读，互斥的写 		 * @param key	 * @return	 */	public Object getData(String key){		rwl.readLock().lock();		Object value = null;		try{			value = cache.get(key);			if(value == null){				rwl.readLock().unlock();  //释放读锁				rwl.writeLock().lock();   //添加写锁				try{					if(value == null){  //放置其他线程加载数据						value = "去数据库查询"; //这里模拟从数据库查询						if(value == null){							//TODO 抛出异常						}					}				}finally{					rwl.writeLock().unlock();				}				rwl.readLock().lock();  //锁还给读线程			}		}finally{			rwl.readLock().unlock();		}		return value;	}}

1、获取读锁，读取数据

2、如果有数据则直接返回，并释放读锁让其他线程读。

3、如果内存中没有数据则从数据库写入内存，释放读锁并添加写锁（这样写入数据就可以达到可以互斥）

4、读入内存后释放写锁并还回读锁（和后面的unlock()对应）

5、如果在添加写锁的时候同时有多个线程，则只能有其中一个线程抢到锁，等拥有锁的线程释放写锁后，其他线程就会抢到写锁，但是此时数据已经写入内存，则需要判断内存数据是否为null如果不为null则直接释放写锁。

1楼lihao__昨天 23:26

不错 学习了