你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写

思路：java.util.concurrent.locks包下面ReadWriteLock接口,该接口下面的实现类ReentrantReadWriteLock维护了两个锁读锁和解锁，可用该类实现这个功能，很简单

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

/**
* 你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
* @author user
*
*/
public class Test2 {

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

@Override
public void run() {
MyData.read();
}
}).start();
}
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {

@Override
public void run() {
MyData.write("a");
}
}).start();
}
}
}

class MyData{
//数据
private static String data = "0";
//读写锁
private static ReadWriteLock rw = new ReentrantReadWriteLock();
//读数据
public static void read(){
rw.readLock().lock();
System.out.println(Thread.currentThread()+"读取一次数据："+data+"时间："+new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
rw.readLock().unlock();
}
}
//写数据
public static void write(String data){
rw.writeLock().lock();
System.out.println(Thread.currentThread()+"对数据进行修改一次："+data+"时间："+new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
rw.writeLock().unlock();
}
}
}

运行结果如下：

Thread[Thread-5,5,main]对数据进行修改一次：a时间：Sun Sep 10 20:52:07 CST 2017
Thread[Thread-4,5,main]对数据进行修改一次：a时间：Sun Sep 10 20:52:08 CST 2017
Thread[Thread-3,5,main]对数据进行修改一次：a时间：Sun Sep 10 20:52:09 CST 2017
Thread[Thread-2,5,main]读取一次数据：0时间：Sun Sep 10 20:52:10 CST 2017
Thread[Thread-0,5,main]读取一次数据：0时间：Sun Sep 10 20:52:10 CST 2017
Thread[Thread-1,5,main]读取一次数据：0时间：Sun Sep 10 20:52:10 CST 2017

分析结果可知：读取的时候都是同一个时间，而修改数据是不同时间的