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

admin 4个月前
   <h2>前言</h2>    <p>相信磁盘缓存在绝大部分的app上都有应用,相对于数据库缓存来说,可以不要注重于缓存的管理,比较开放和随意。</p>    <p>再加上jakewharton早年间发布的disklrucache框架,让我们使用磁盘缓存更加简单,效率上和数据库缓存也拉进了一步,以后有时间我在加上disklrucache的缓存解读。</p>    <p>但是在多线程的环境下,对同一份数据进行读写,会涉及到线程安全的问题。比如在一个线程读取数据的时候,另外一个线程在写数据,而导致前后数据的不一致性;一个线程在写数据的时候,另一个线程也在写,同样也会导致线程前后看到的数据的不一致性。更严重的是一个线程在写的时候,另一个线程在读。这里的数据不一致是对于文件来说的,当文件里的数据存储的json时,残缺的数据或者不完整的数据无法生成对象,判断没有写好甚至是报错闪退。</p>    <h2>常见解决方案</h2>    <p>使用Synchronized同步锁保护线程安全,但是Synchronized存在明显的一个性能问题就是读与读之间互斥,也就是说两个线程的读操作是顺序执行的 下面给大家看下代码方便理解</p>    <pre>  <code class="language-java">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());      }</code></pre>    <p>我们来看一下运行结果,结论两个两个线程的读操作是顺序执行的,如果读的次数多这个太影响性能了</p>    <p><img src="https://simg.open-open.com/show/495e5606ecf6f1eb0d5318a4240c541f.png" alt="Android读写锁的应用,以及最佳的磁盘缓存设计" width="485" height="109"></p>    <h2>思考</h2>    <p>最佳的方案通俗的来讲应该是,可以很多人同时读,但不能同时写,有人在写的时候不能同时读也不能同时写,官方说法是读和读互不影响,读和写互斥,写和写互斥,好了接下来就是介绍今天的主角ReadWriteLock 读写锁</p>    <h3>ReadWriteLock介绍</h3>    <p>1.1 ReadWriteLock的位置</p>    <p>ReadWriteLock是Java自带的 所处位置 java.util.concurrent.locks,属于java并发方案中的一种</p>    <p>1.2 ReadWriteLock是一个接口,主要有两个方法,如下</p>    <pre>  <code class="language-java">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();  }</code></pre>    <p>既然只是接口,那我们真正要用的是实现了该接口的类 ReentrantReadWriteLock 可重入读写锁</p>    <p>1.3可重人</p>    <p>可重入锁,就是说一个线程在获取某个锁后,还可以继续获取该锁,即允许一个线程多次获取同一个锁。通俗的来讲就是支持在同一个线程里面对多个文件进行读写操作,都可以获取同一个锁,但是获取多少锁就要回收多少锁,下面给个例子方便理解</p>    <pre>  <code class="language-java">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(); 获取两次锁,只释放一次锁                }</code></pre>    <p>运行结果</p>    <p><img src="https://simg.open-open.com/show/5f8bb7bf6a78d8786f288ad4976b89ec.png" alt="Android读写锁的应用,以及最佳的磁盘缓存设计" width="460" height="63"></p>    <p>注意:因为主线程2次获取了锁,但是却只释放1次锁,造成死锁,导致新线程永远也不能获取锁。一个线程获取多少次锁,就必须释放多少次锁</p>    <p>1.4 获取锁顺序</p>    <ul>     <li> <p>非公平模式(默认)</p> <p>当以非公平初始化时,读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取,可能会延缓一个或多个读或写线程,但是会比公平锁有更高的吞吐量。</p> </li>     <li> <p>公平模式</p> <p>当以公平模式初始化时,线程将会以队列的顺序获取锁。当当前线程释放锁后,等待时间最长的写锁线程就会被分配写锁;或者有一组读线程组等待时间比写线程长,那么这组读线程组将会被分配读锁。</p> </li>     <li> <p>源码如下</p> </li>    </ul>    <pre>  <code class="language-java">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);      }</code></pre>    <p>1.5 锁升级和锁降级</p>    <ul>     <li>锁降级:从写锁变成读锁;</li>     <li>锁升级:从读锁变成写锁。</li>     <li>ReentrantReadWriteLock 只支持锁降级</li>     <li>建议尽量不要使用锁降级操作,获取什么锁就回收什么锁,同一线程尽量不要使用两种锁,最为安全,除非有特殊操作则需注意</li>    </ul>    <p>2 磁盘缓存最佳设计</p>    <p>提供抽象类BaseCache的源码,具体实现大家可以通过自己的实际情况去拓展</p>    <pre>  <code class="language-java">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();  }</code></pre>    <p> </p>    <p>来自: http://www.jianshu.com/p/4c925ebf3d34</p>