1. Technical background

In actual project development, we often use caching middleware (such as redis, MemCache, etc.) to help us improve the availability and robustness of the system.

But many times if the project is relatively simple, there is no need to specifically introduce middleware such as Redis to use cache to increase the complexity of the system. So does Java itself have any useful lightweight caching components?

The answer is of course yes, and there is more than one way. Common solutions include: ExpiringMap, LoadingCache and HashMap-based packaging.

2. Technical effect

• Realize common functions of cache, such as outdated deletion strategy

• Hot data warm-up

3. ExpiringMap

3.1 Function Introduction

• Entries in the Map can be set to automatically expire after a period of time.

• You can set the maximum capacity value of the Map. When the Maximum size is reached, inserting a value again will cause the first value in the Map to expire.

• You can add listening events and schedule the listening function when the Entry expires.

• You can set up lazy loading and create objects when the get() method is called.

3.2 Source code

github address

3.3 Example

Add dependency (Maven)

<dependency> 
    <groupId>net.jodah</groupId> 
    <artifactId>expiringmap</artifactId> 
    <version>0.5.8</version> 
</dependency>

Example source code

public class ExpiringMapApp {

    public static void main(String[] args) {
        // maxSize: 設(shè)置最大值,添加第11個entry時，會導致第1個立馬過期(即使沒到過期時間)
        // expiration：設(shè)置每個key有效時間10s, 如果key不設(shè)置過期時間，key永久有效。
        // variableExpiration: 允許更新過期時間值,如果不設(shè)置variableExpiration，不允許后面更改過期時間,一旦執(zhí)行更改過期時間操作會拋異常UnsupportedOperationException
        // policy:
        //        CREATED: 只在put和replace方法清零過期時間
        //        ACCESSED: 在CREATED策略基礎(chǔ)上增加, 在還沒過期時get方法清零過期時間。
        //        清零過期時間也就是重置過期時間，重新計算過期時間.
        ExpiringMap<String, String> map = ExpiringMap.builder()
            .maxSize(10)
            .expiration(10, TimeUnit.SECONDS)
            .variableExpiration().expirationPolicy(ExpirationPolicy.CREATED).build();

        map.put("token", "lkj2412lj1412412nmlkjl2n34l23n4");
        map.put("name", "管理員", 20000, TimeUnit.SECONDS);

        // 模擬線程等待...
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("token ===> " + map.get("token"));
        System.out.println("name ===> " + map.get("name"));

        // 注意： 在創(chuàng)建map時，指定的那些參數(shù)如過期時間和過期策略都是全局的, 對map中添加的每一個entry都適用.
        //        在put一個entry鍵值對時可以對當前entry 單獨設(shè)置 過期時間、過期策略,只對當前這個entry有效.
    }
}

Run result

##token ===> null

name ===> Administrator

Attention

When creating a map, the specified parameters such as expiration time and expiration policy are global and apply to every entry added to the map.
When putting an entry key-value pair, you can set the expiration time and expiration policy separately for the current entry, which is only valid for the current entry.

4. LoadingCache

4.1 Function Introduction

A thread-safe local caching solution open sourced by Google.

Features: Provide cache recycling mechanism, monitor cache loading/hit status, flexible and powerful functions, simple and easy-to-use API.

4.2 Example

Source code

public class LoadingCacheApp {

    public static void main(String[] args) throws Exception {
        // maximumSize: 緩存池大小，在緩存項接近該大小時， Guava開始回收舊的緩存項
        // expireAfterAccess: 設(shè)置時間對象沒有被讀/寫訪問則對象從內(nèi)存中刪除(在另外的線程里面不定期維護)
        // removalListener: 移除監(jiān)聽器,緩存項被移除時會觸發(fā)的鉤子
        // recordStats: 開啟Guava Cache的統(tǒng)計功能
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .expireAfterAccess(10, TimeUnit.SECONDS)
            .removalListener(new RemovalListener<String, String>() {
                @Override
                public void onRemoval(RemovalNotification<String, String> removalNotification) {
                    System.out.println("過時刪除的鉤子觸發(fā)了... key ===> " + removalNotification.getKey());
                }
            })
            .recordStats()
            .build(new CacheLoader<String, String>() {
                // 處理緩存鍵不存在緩存值時的處理邏輯
                @Override
                public String load(String key) throws Exception {
                    return "不存在的key";
                }
            });

        cache.put("name", "小明");
        cache.put("pwd", "112345");

        // 模擬線程等待...
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("token ===> " + cache.get("name"));
        System.out.println("name ===> " + cache.get("pwd"));
    }
}

Run result

The outdated deletion hook triggered... key ===> name

token ===> Non-existent key
The obsolete deletion hook triggered... key ===> pwd
name ===> Non-existent key

4.3 Removal mechanism

When guava caches data, there are two types of data removal: passive removal and active removal.

Passive removal

• Size-based removal: When the number reaches the specified size, uncommon key values ??will be removed

• Time-based removal: expireAfterAccess(long, TimeUnit) removes a key-value pair based on the time after the last access. expireAfterWrite(long, TimeUnit) Remove based on the time after a key-value pair is created or the value is replaced

• Reference-based removal: mainly based on Java's garbage collection mechanism. Determine removal based on the reference relationship of the key or value

Active removal

• Remove individually: Cache.invalidate(key)

• Batch removal: Cache.invalidateAll(keys)

• Remove all: Cache.invalidateAll()

If the removal listener RemovalListener is configured, the logic under the listener will be executed synchronously during all removal actions.

If you need to change to asynchronous, use: RemovalListeners.asynchronous(RemovalListener, Executor).

4.4 Others

• Before the put operation, if it has With this key value, removeListener will be triggered first to remove the listener, and then

• is configured with expireAfterAccess and expireAfterWrite, but it is not removed after the specified time.

• Delete policy logic:

The cache built by CacheBuilder will not automatically perform cleaning and recycling work at a specific time, nor will it be executed at a certain time. The cache item is cleared immediately after it expires. It does not start a thread for cache maintenance, because firstly the thread is relatively heavy, and secondly some environments limit the creation of threads.

It will do a small amount of maintenance work during write operations, or occasionally during read operations. Of course, you can also create your own maintenance thread and call Cache.cleanUp() at fixed intervals.

The above is the detailed content of How to set expiration time map in Java. For more information, please follow other related articles on the PHP Chinese website!