java5 ReadWriteLock用法--读写锁实现_reentrantreadwritelock-优快云博客

本文介绍读写锁的工作原理及其应用场景，通过实例演示如何使用读写锁控制多线程对共享资源的访问。此外，还提供了一个缓存系统的实现方案，利用读写锁优化数据读取效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

三个线程读数据，三个线程写数据示例：
可以同时读，读的时候不能写，不能同时写，写的时候不能读。
读的时候上读锁，读完解锁；写的时候上写锁，写完解锁。
注意finally解锁。

package 
com.ljq.test.thread;
 
import 
java.util.Random;
import 
java.util.concurrent.locks.ReadWriteLock;
import 
java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 读写锁
 *
 * @author Administrator
 *
 */
public 
class ReadWriteLockTest {
    public
static void 
main(String[] args) {
        final
ReadWrite rw = new
ReadWrite();
        for
(int 
i = 0; i < 
3; i++) {
            new
Thread() {
                public
void run() {
                    while
(true) {
                        rw.read();
                    }
                }
 
            }.start();
 
            new
Thread() {
                public
void run() {
                    while
(true) {
                        rw.write(new
Random().nextInt(10000));
                    }
                }
 
            }.start();
        }
 
    }
}
 
/**
 * 读和写要互斥，因此要把它们放在同一个类中
 *
 * @author Administrator
 *
 */
class 
ReadWrite {
    private
Object data = null;//共享数据，只能有一个线程写该数据，但可以有多个线程同时读该数据。
    ReadWriteLock rwl =
new ReentrantReadWriteLock();
 
    /**
     * 读数据
     */
    public
void read() {
         
        rwl.readLock().lock();
        try
{
            System.out.println(Thread.currentThread().getName() +
" be 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();
        }
         
    }
 
    /**
     * 写数据
     *
     * @param data
     */
    public
void write(Object data) {
         
        rwl.writeLock().lock();
        try
{
            System.out.println(Thread.currentThread().getName() +
" be 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();
        }
 
    }
}

设计一个缓存系统
缓存系统：你要取数据，需调用我的public Object getData(String key)方法，我要检查我内部有没有这个数据，如果有就直接返回，如果没有，就从数据库中查找这个数，查到后将这个数据存入我内部的存储器中，下次再有人来要这个数据，我就直接返回这个数不用再到数据库中找了。你要取数据不要找数据库，来找我。

package 
com.ljq.test.thread;
 
import 
java.util.HashMap;
import 
java.util.Map;
import 
java.util.concurrent.locks.ReadWriteLock;
import 
java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 设计一个缓存系统
 *
 *
 * @author Administrator
 *
 */
public 
class CacheDemo {
 
    private
Map<String, Object> cache = new
HashMap<String, Object>();
 
    public
static void 
main(String[] args) {
        String key =
"name";
        CacheDemo cacheDemo =
new CacheDemo();
        System.out.println(cacheDemo.getData(key));
//从数据库获取数据
        System.out.println(cacheDemo.getData(key));
//从缓存获取数据
        System.out.println(cacheDemo.getData(key));
//从缓存获取数据
    }
 
    private
ReadWriteLock rwl = new
ReentrantReadWriteLock();
 
    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) {
//再次进行判断，防止多个写线程堵在这个地方重复写
                        System.out.println("read data from database");
                        value =
"张三";
                        cache.put(key, value);
                    }
                }
finally {
                    //设置完成 释放写锁
                    rwl.writeLock().unlock();
                }
                //恢复读写状态
                rwl.readLock().lock();
            }else{
                System.out.println("read data from cache");
            }
        }
finally {
            rwl.readLock().unlock();
//释放读锁
        }
        return
value;
    }
}

返回结果：