【业务功能篇140】ConcurrentHashMap缓存用户信息

ConcurrentHashMap的简要总结：

1、public V get(Object key)不涉及到锁，也就是说获得对象时没有使用锁；

2、put、remove方法要使用锁，但并不一定有锁争用，原因在于ConcurrentHashMap将缓存的变量分到多个Segment，每个Segment上有一个锁，只要多个线程访问的不是一个Segment就没有锁争用，就没有堵塞，各线程用各自的锁，ConcurrentHashMap缺省情况下生成16个Segment，也就是允许16个线程并发的更新而尽量没有锁争用；

3、Iterator对象的使用，不一定是和其它更新线程同步，获得的对象可能是更新前的对象，ConcurrentHashMap允许一边更新、一边遍历，也就是说在Iterator对象遍历的时候，ConcurrentHashMap也可以进行remove,put操作，且遍历的数据会随着remove,put操作产出变化，所以希望遍历到当前全部数据的话，要么以ConcurrentHashMap变量为锁进行同步(synchronized该变量)，要么使用CopiedIterator包装iterator，使其拷贝当前集合的全部数据，但是这样生成的iterator不可以进行remove操作。

Hashtable和ConcurrentHashMap的不同点：

1、Hashtable对get,put,remove都使用了同步操作，它的同步级别是正对Hashtable来进行同步的，也就是说如果有线程正在遍历集合，其他的线程就暂时不能使用该集合了，这样无疑就很容易对性能和吞吐量造成影响，从而形成单点。而ConcurrentHashMap则不同，它只对put,remove操作使用了同步操作，get操作并不影响，详情请看以上第1,2点，当前ConcurrentHashMap这样的做法对一些线程要求很严格的程序来说，还是有所欠缺的，对应这样的程序来说，如果不考虑性能和吞吐量问题的话，个人觉得使用Hashtable还是比较合适的；原文链接：https://blog.csdn.net/sureSand/article/details/82190636

缓存工具类

public class CacheUtils{
    private static Map<String, CacheData> CACHE_DATA = new ConcurrentHashMap<>();
    /**
     * getData   通过该方法进行获取缓存
     *
     * @param key key
     * @return T
     */
    public static <T> T getData(String key) {
        CacheData<T> data = CACHE_DATA.get(key);
        if (data != null && (data.getExpire() <= 0 || data.getSaveTime() >= System.currentTimeMillis())) {
            return data.getData();
        }
        return null;
    }

    /**
     * setData
     *
     * @param key key
     * @param data data
     * @param expire expire
     */
    public static <T> void setData(String key, T data, int expire) {
        CACHE_DATA.put(key, new CacheData(data, expire));
    }

    /**
     * clear
     *
     * @param key key
     */
    public static void clear(String key) {
        CACHE_DATA.remove(key);
    }

    /**
     * 清除所有缓存数据
     */
    public static void clearAll() {
        CACHE_DATA.clear();
    }


    private static class CacheData<T> {
        CacheData(T t, int expire) {
            this.data = t;
            this.expire = expire <= 0 ? 0 : expire;
            this.saveTime = System.currentTimeMillis() + this.expire;
        }

        private T data;

        private long saveTime; // 存活时间

        private long expire;   // 过期时间 小于等于0标识永久存活

        public T getData() {
            return data;
        }

        public long getExpire() {
            return expire;
        }

        public long getSaveTime() {
            return saveTime;
        }
    }
}

业务调用

    @Override
    public UserVo getUserStrategy() {
        String Uid = getUid(request);
        if (Uid == null) {
            return null;
        }
		//从缓存取
        UserVo userVo = CacheUtils.getData(Uid);
        if (userVo != null) {
            return userVo;
        }
		//缓存没有从数据库取
        User user = userMapper.getUserStrategyByUid(Uid);
        if (user != null) {
            userVo = new UserVo().convertFromUser(user);
			//存到缓存
            CacheUtils.setData(Uid, userVo, 1000 * 60 * 60);
			//返回用户信息
            return userVo;
        }
		//如果数据库没有从第三方接口平台获取，然后放入数据库
        UserVo otherrUser = getUserStrategy(Uid);
		//再放到缓存
        CacheUtils.setData(Uid, otherrUser, 1000 * 60 * 60);
        return otherrUser;
    }
    /**
     * getUid 从session获取用户的ID
     * 
     * @param request request
     * @return String
     */
    private String getUid(HttpServletRequest request) {
        if (request == null) {
            return null;
        }
        User User = (User) request.getSession()
            .getAttribute("SESSION_USER");
        if (User == null) {
            return null;
        }
        return User.getUid();
		
		
	//UserVo类中的转换对象方法，写在UserVO中
		
	public UserVo convertFromUser(User user) {
        BeanUtils.copyProperties(user, this);
        return this;
    }
    }

更多：
https://blog.csdn.net/qq_35030994/article/details/80871279
https://blog.csdn.net/coding_ss/article/details/107184035
https://blog.csdn.net/Clsrm/article/details/122564673