java本地缓存方案

package org.jeecg.modules.localcache;

import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @version 1.0
 * @Author zhaozhiqiang
 * @Date 2023/7/10 9:42
 * @Description //线程安全追求吞吐量，不耗cpu
 */
public class CacheUtil {

    public static void main(String[] args) throws InterruptedException {
        for ( int i = 0; i <100000 ; i++) {
            CacheUtil.put(""+i,1,1);
            System.out.println(i);
        }

//       new Thread(new Runnable() {
//           @Override
//           public void run() {
//               for ( int i = 0; i <100000 ; i++) {
//                   Object o = get("" + i);
//                   if(null!=o){
//                       System.out.println(o);
//                   }
//               }
//
//           }
//       }).start();
    }
    //默认大小
    private static final int DEFAULT_CAPACITY = 1024;

    // 最大缓存大小
    private static final int MAX_CAPACITY = 10000;

    //默认缓存过期时间
    private static final long DEFAULT_TIMEOUT = 3600;

    //1000毫秒
    private static final long SECOND_TIME = 1000;

    //存储缓存的Map
    private static final ConcurrentHashMap<String, Object> map;

    private static final Timer timer;

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

    //私有化构造方法
    private CacheUtil() {

    }

    /**
     * 缓存任务清除类
     */
    static class ClearTask extends TimerTask {
        private String key;

        public ClearTask(String key) {
            this.key = key;
        }

        @Override
        public void run() {
            CacheUtil.remove(key);
        }

    }


    /**
     * 添加缓存
     *
     * @param key
     * @param object
     * @return
     */
    public static boolean put(String key, Object object) {
        if (checkCapacity()) {
            map.put(key, object);
            //默认缓存时间
            timer.schedule(new ClearTask(key), DEFAULT_TIMEOUT);
            return true;
        }
        return false;
    }

    /**
     * 添加缓存
     * @param key
     * @param object
     * @param time_out
     * @return
     */
    public static boolean put(String key, Object object, int time_out) {
        if (checkCapacity()) {
            map.put(key, object);
            //默认缓存时间
            timer.schedule(new ClearTask(key), time_out * SECOND_TIME);
        }
        return false;
    }


    /**
     * 判断容量大小
     *
     * @return
     */
    public static boolean checkCapacity() {
        return map.size() < MAX_CAPACITY;
    }

    /**
     * 批量增加缓存
     *
     * @param m
     * @param time_out
     * @return
     */
    public static boolean put(Map<String, Object> m, int time_out) {
        if (map.size() + m.size() <= MAX_CAPACITY) {
            map.putAll(m);
            for (String key : m.keySet()) {
                timer.schedule(new ClearTask(key), time_out * SECOND_TIME);
            }
            return true;
        }
        return false;
    }

    /**
     * 删除缓存
     *
     * @param key
     */
    public static void remove(String key) {
        map.remove(key);
    }

    /**
     * 清除所有缓存
     */
    public void clearAll() {
        if (map.size() > 0) {
            map.clear();
        }
        timer.cancel();
    }

    /**
     * 获取缓存
     * @param key
     * @return
     */
    public static Object get(String key) {
        return map.get(key);
    }

    /**
     * 是否包含某个缓存
     * @param key
     * @return
     */
    public static boolean isContain(String key) {
        return map.contains(key);
    }


}

package org.jeecg.modules.localcache;

import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;


/**
 * @version 1.0
 * @Author zhaozhiqiang
 * @Date 2023/7/10 10:22
 * @Description //TODO线程安全追求的响应时间，耗cpu，服务处理器一定要好
 */
public class CacheUtil2 {

    public static void main(String[] args) {
        for ( int i = 0; i <100000 ; i++) {
            CacheUtil2.put(""+ i, i,100);
            System.out.println(i);
        }
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                for ( int i = 0; i <100000 ; i++) {
//                    CacheUtil2.put(""+ i, i,100);
//
//                }
//
//            }
//        }).start();
//
//        for ( int i = 0; i <100000 ; i++) {
//            int finalI = i;
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    Object o = get("" + finalI);
//                    if(null!=o){
//                        System.out.println(o);
//                    }
//
//                }
//            }).start();
//        }
    }
    /**
     * 可重入读写锁，保证并发读写安全性
     */
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    //默认大小
    private static final int DEFAULT_CAPACITY = 1024;
    //用volatile修饰的ConcurrentHashMap保证在多线程之间的可见性
    volatile static Map<String, Object> cachMap = new HashMap<String, Object>(DEFAULT_CAPACITY);
    private static Timer timer = new Timer();
    // 最大缓存大小
    private static final int MAX_CAPACITY = 10000;

    public static Object get(String key) {
        readLock.lock();
        try {
            return cachMap.get(key);
        } finally {
            readLock.unlock();
        }
    }

    public static void put(String key, Object value, long DEFAULT_TIMEOUT) {
        writeLock.lock();
        try {
            if (checkCapacity()) {
                //默认缓存时间
                timer.schedule(new CacheUtil.ClearTask(key), DEFAULT_TIMEOUT);
                cachMap.put(key, value);
            }

        } finally {
            writeLock.unlock();
        }
    }

    public static Object remove(String key) {
        writeLock.lock();
        try {
            return cachMap.remove(key);
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 清除所有缓存
     */
    public void clearAll() {
        if (cachMap.size() > 0) {
            cachMap.clear();
        }
        timer.cancel();
    }

    /**
     * 缓存任务清除类
     */
    static class ClearTask extends TimerTask {
        private String key;

        public ClearTask(String key) {
            this.key = key;
        }

        @Override
        public void run() {
            CacheUtil2.remove(key);
        }

    }

    /**
     * 判断容量大小
     *
     * @return
     */
    public static boolean checkCapacity() {
        return cachMap.size() < MAX_CAPACITY;
    }


    /**
     * 是否包含某个缓存
     *
     * @param key
     * @return
     */
    public static boolean isContain(String key) {
        return cachMap.containsKey(key);

    }
}