Java local cache code example

This article mainly introduces the implementation code of Java local cache. The editor thinks it is quite good. Now I will share it with you and give it as a reference. Let’s follow the editor and take a look.

Usage scenarios

In Java applications, for data with high access frequency and few updates, usually The best solution is to add this type of data to the cache. Compared with reading from the database, the read cache efficiency will be greatly improved.

In a cluster environment, commonly used distributed caches include Redis, Memcached, etc. However, in some business scenarios, it may not be necessary to build a complex distributed caching system. In a stand-alone environment, you usually want to use the internal cache (LocalCache).

Implementation

There are two implementations of LocalCache , one is based on Con<a href="http://www.php.cn/wiki/1046.html" target="_blank">current</a><a href="http://www.php.cn/wiki/762.html" target="_blank">Hash</a><a href="http://www.php.cn/code/8210.html" target="_blank">Map</a> implements basic local caching, and the other is local caching based on LinkedHashMap that implements LRU strategy.

Implementation based on ConcurrentHashMap

static {
  timer = new Timer();
  map = new ConcurrentHashMap<>();
}

Uses ConcurrentHashMap as the cache storage structure. Because ConcurrentHashMap 's thread is safe , the LocalCache based on this implementation is safe to operate in a multi-threaded concurrent environment. In JDK1.8 , ConcurrentHashMap supports fully concurrent reading, which also improves the efficiency of local cache. The cache operation is implemented by calling ConcurrentHashMap to operate on map .

PrivateConstructor

privateLocalCache(){

}

LocalCache is a tool class, passed private Constructors enhance the ability to be non-instantiable.

Cache clearing mechanism

/**
 * 清除缓存任务类
 */
 static classCleanWorkerTaskextendsTimerTask{

   private String key;

   publicCleanWorkerTask(String key){
     this.key = key;
   }

   publicvoidrun(){
     LocalCache.remove(key);
   }
 }

Clearing invalid caches is implemented by the Timer class. Inner class CleanWorkerTask Inherits from TimerTask User clears cache. Whenever a new element is added, timer.schedule will be called to load the task of clearing the cache.

Implementation based on LinkedHashMap

Uses LinkedHashMap as the cache storage structure. The LRU strategy is mainly implemented through the LinkedHashMap feature of access sequence.

LRU

LRU is the abbreviation of Least Recently Used , that is, it has not been used for the longest time. LRU cache will use this algorithm to eliminate old data elements in the cache to optimize memory space.

Map based on LRU strategy

Here we use LinkedHashMap to implement map ## based on LRU strategy #. Instantiate map by calling the constructor of the parent class LinkedHashMap . Parameter accessOrder is set to true to ensure that it can implement the LRU policy.

static classLRUMap<K,V>extendsLinkedHashMap<K,V>{

    ... // 省略部分代码
    
    publicLRUMap(intinitialCapacity,floatloadFactor){
      super(initialCapacity, loadFactor, true);
    }

    ... // 省略部分代码
    
    /**
     * 重写LinkedHashMap中removeEldestEntry方法;
     * 新增元素的时候,会判断当前map大小是否超过DEFAULT_MAX_CAPACITY,超过则移除map中最老的节点;
     *
     * @param eldest
     * @return
     */
    protectedbooleanremoveEldestEntry(Map.Entry<K, V> eldest){
      return size() > DEFAULT_MAX_CAPACITY;
    }

  }

Thread safety

##

/**
 * 读写锁
 */
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

private final Lock rLock = readWriteLock.readLock();

private final Lock wLock = readWriteLock.writeLock();

LinkedHashMap

is not a thread Security, if used in a multi-threaded environment without control, there will be problems. Therefore, ReentrantReadWriteLock read-write lock was introduced in LRUMap to control concurrency issues.

Cache elimination mechanism

protectedbooleanremoveEldestEntry(Map.Entry<K, V> eldest){
  return size() > DEFAULT_MAX_CAPACITY;
}

Rewrite hereLinkedHashMap

中removeEldestEntry Method, when a new element is cached, it will be judged whether the current map size exceeds DEFAULT_MAX_CAPACITY . If it exceeds, the oldest node in the map will be removed.

Cache clearing mechanism

The cache clearing mechanism is consistent with the implementation of

ConcurrentHashMap

, both are implemented through timer . 【Related Recommendations】

1.

Special Recommendation: "php Programmer Toolbox" V0.1 version download2.

Java Free Video Tutorial

3.

YMP Online Manual

The above is the detailed content of Java local cache code example. For more information, please follow other related articles on the PHP Chinese website!