Android读写锁的应用，以及最佳的磁盘缓存设计

时间 2019-11-07

原文原文链接

前言

相信磁盘缓存在绝大部分的app上都有应用，相对于数据库缓存来讲，能够不要注重于缓存的管理，比较开放和随意。再加上jakewharton早年间发布的disklrucache框架，让咱们使用磁盘缓存更加简单，效率上和数据库缓存也拉进了一步，之后有时间我在加上disklrucache的缓存解读。java

可是在多线程的环境下，对同一份数据进行读写，会涉及到线程安全的问题。好比在一个线程读取数据的时候，另一个线程在写数据，而致使先后数据的不一致性；一个线程在写数据的时候，另外一个线程也在写，一样也会致使线程先后看到的数据的不一致性。更严重的是一个线程在写的时候，另外一个线程在读。这里的数据不一致是对于文件来讲的，当文件里的数据存储的json时，残缺的数据或者不完整的数据没法生成对象，判断没有写好甚至是报错闪退。数据库

常看法决方案

使用Synchronized同步锁保护线程安全，可是Synchronized存在明显的一个性能问题就是读与读之间互斥，也就是说两个线程的读操做是顺序执行的下面给你们看下代码方便理解json

public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                read(Thread.currentThread());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                read(Thread.currentThread());
            }
        }).start();

    }

    public synchronized static void read(Thread thread){
        System.out.println("开始运行时间:"+System.currentTimeMillis());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束运行时间:"+System.currentTimeMillis());
    }

复制代码

咱们来看一下运行结果,结论两个两个线程的读操做是顺序执行的，若是读的次数多这个太影响性能了缓存

思考

最佳的方案通俗的来说应该是，能够不少人同时读，但不能同时写，有人在写的时候不能同时读也不能同时写，官方说法是读和读互不影响，读和写互斥，写和写互斥，好了接下来就是介绍今天的主角ReadWriteLock 读写锁安全

ReadWriteLock介绍

1.1 ReadWriteLock的位置

ReadWriteLock是Java自带的所处位置 java.util.concurrent.locks，属于java并发方案中的一种bash

1.2 ReadWriteLock是一个接口，主要有两个方法，以下

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

复制代码

既然只是接口，那咱们真正要用的是实现了该接口的类 ReentrantReadWriteLock 可重入读写锁多线程

1.3可重入

可重入锁，就是说一个线程在获取某个锁后，还能够继续获取该锁，即容许一个线程屡次获取同一个锁。通俗的来说就是支持在同一个线程里面对多个文件进行读写操做，均可以获取同一个锁，可是获取多少锁就要回收多少锁，下面给个例子方便理解并发

public static void main(String[] args) {

        final ReadWriteLock lock = new ReentrantReadWriteLock();

        lock.writeLock().lock();
        lock.writeLock().lock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                lock.writeLock().lock();
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程运行");
                lock.writeLock().unlock();
            }
        }).start();

        System.out.println("主线程运行");
        lock.writeLock().unlock();
//        lock.writeLock().unlock(); 获取两次锁，只释放一次锁
        
    }

复制代码

运行结果 app

注意：由于主线程2次获取了锁，可是却只释放1次锁，形成死锁，致使新线程永远也不能获取锁。一个线程获取多少次锁，就必须释放多少次锁

1.4 获取锁顺序

非公平模式（默认）框架

当以非公平初始化时，读锁和写锁的获取的顺序是不肯定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，可是会比公平锁有更高的吞吐量。
公平模式

当以公平模式初始化时，线程将会以队列的顺序获取锁。当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。
源码以下

public ReentrantReadWriteLock() {
        this(false);
    }

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

复制代码

1.5 锁升级和锁降级

锁降级：从写锁变成读锁;
锁升级：从读锁变成写锁。
ReentrantReadWriteLock 只支持锁降级
建议尽可能不要使用锁降级操做，获取什么锁就回收什么锁，同一线程尽可能不要使用两种锁，最为安全，除非有特殊操做则需注意

2 磁盘缓存最佳设计

提供抽象类BaseCache的源码，具体实现你们能够经过本身的实际状况去拓展

public abstract class BaseCache {

    private final ReadWriteLock mLock = new ReentrantReadWriteLock();

    /**
     * 读取缓存
     *
     * @param key       缓存key
     * @param existTime 缓存时间
     */
    final <T> T load(Type type, String key, long existTime) {
        //1.先检查key
        Utils.checkNotNull(key, "key == null");

        //2.判断key是否存在,key不存在去读缓存没意义
        if (!containsKey(key)) {
            return null;
        }

        //3.判断是否过时，过时自动清理
        if (isExpiry(key, existTime)) {
            remove(key);
            return null;
        }

        //4.开始真正的读取缓存
        mLock.readLock().lock();
        try {
            // 读取缓存
            return doLoad(type, key);
        } finally {
            mLock.readLock().unlock();
        }
    }

    /**
     * 保存缓存
     *
     * @param key   缓存key
     * @param value 缓存内容
     * @return
     */
    final <T> boolean save(String key, T value) {
        //1.先检查key
        Utils.checkNotNull(key, "key == null");

        //2.若是要保存的值为空,则删除
        if (value == null) {
            return remove(key);
        }

        //3.写入缓存
        boolean status = false;
        mLock.writeLock().lock();
        try {
            status = doSave(key, value);
        } finally {
            mLock.writeLock().unlock();
        }
        return status;
    }

    /**
     * 删除缓存
     */
    final boolean remove(String key) {
        mLock.writeLock().lock();
        try {
            return doRemove(key);
        } finally {
            mLock.writeLock().unlock();
        }
    }


    /**
     * 获取缓存大小
     * @return
     */
    long size() {
        return getSize();
    }

    /**
     * 清空缓存
     */
    final boolean clear() {
        mLock.writeLock().lock();
        try {
            return doClear();
        } finally {
            mLock.writeLock().unlock();
        }
    }

    /**
     * 是否包含 加final 是让子类不能被重写，只能使用doContainsKey
     * 这里加了锁处理，操做安全。<br>
     *
     * @param key 缓存key
     * @return 是否有缓存
     */
    public final boolean containsKey(String key) {
        mLock.readLock().lock();
        try {
            return doContainsKey(key);
        } finally {
            mLock.readLock().unlock();
        }
    }

    /**
     * 是否包含  采用protected修饰符  被子类修改
     */
    protected abstract boolean doContainsKey(String key);

    /**
     * 是否过时
     */
    protected abstract boolean isExpiry(String key, long existTime);

    /**
     * 读取缓存
     */
    protected abstract <T> T doLoad(Type type, String key);

    /**
     * 保存
     */
    protected abstract <T> boolean doSave(String key, T value);

    /**
     * 删除缓存
     */
    protected abstract boolean doRemove(String key);

    /**
     * 清空缓存
     */
    protected abstract boolean doClear();

    /**
     * 获取缓存大小
     *
     * @return
     */
    protected abstract long getSize();
}

复制代码