demo缓存 refersh()可以用java.util.concurrent包中的Executors.newSingleThreadScheduledExecutor定时器触发

import java.util.List;

public interface CacheService {
    List<OrderInfo> queryOrderInfoByCache(String userId);
}

import com.google.common.cache.RemovalListener;
import com.google.common.cache.RemovalNotification;

public class RemovalListenerImpl implements RemovalListener {
    @Override
    public void onRemoval(RemovalNotification removalNotification) {
        System.out.println("缓存移除 removalNotification = " + removalNotification.getValue());
    }
}

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheServiceImpl implements InitializingBean, CacheService {

    /**
     * 本地加载缓存
     */
    private LoadingCache<String, List<OrderInfo>> loadingCache;

    /**
     * 订单服务
     */
    @Autowired
    private OrderInfoService orderInfoService;

    /**
     * 更新缓存读写锁
     */
    private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

    /**
     * 获取缓存
     */
    private CacheLoader<String, List<OrderInfo>> cacheLoader;

    @SuppressWarnings("unchecked")
    @Override
    public void afterPropertiesSet() {
        Lock readLock = readWriteLock.readLock();
        try {
            readLock.lock();
            cacheLoader = new CacheLoader<String, List<OrderInfo>>() {
                @Override
                public List<OrderInfo> load(String userId) throws Exception {
                    return orderInfoService.getOrderInfoList(userId);
                }
            };
        } catch (Exception e) {
            System.out.println("loggerUtil.warn  打印日志");
        }finally {
            readLock.unlock();
        }

        loadingCache = CacheBuilder
                .newBuilder()
                //cache最大数量
                .maximumSize(5000)
                //并发等级
                .concurrencyLevel(8)
                //初始化容量
                .initialCapacity(10)
                //刷新缓存时间
                .refreshAfterWrite(60 * 60, TimeUnit.SECONDS)
                //缓存命中数
                .recordStats()
                .removalListener(new RemovalListenerImpl())
                .build(cacheLoader);

    }

    @Override
    public List<OrderInfo> queryOrderInfoByCache(String userId) {
        try {
            return cacheLoader.load(userId);
        } catch (Exception e) {
            throw new RuntimeException("");
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Component
@EnableScheduling
public class OrderActive {

    @Autowired
    OrderInfoService orderInfoService;

    private ScheduledExecutorService executorService =
            Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "orderActive");
                }
            });

    /**
     * 并发时读写锁
     */
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    @Scheduled(cron = "0/50 * * * * ?")
    public void checkOrderExpireInfo() {
        //获取过期订单的集合
        System.out.println("开始扫描过期时间");
        long start = System.currentTimeMillis();
        Lock readLock = readWriteLock.readLock();
        List<OrderInfo> orderInfoExpireList;
        try {
            readLock.lock();
            orderInfoExpireList = orderInfoService.getOrderInfoExpireList();
        } finally {
            readLock.unlock();
        }
        Lock writeLock = readWriteLock.writeLock();

        for (OrderInfo orderInfo : orderInfoExpireList) {
            System.out.println("扫描完成");
            writeLock.lock();
            try {
                orderInfoService.setOrderStatus(orderInfo);
            } finally {
                writeLock.unlock();
            }

        }
        long time = System.currentTimeMillis() - start;
        System.out.println("一共扫描了" + orderInfoExpireList.size() + "个订单,更新时间为：" + time + "豪秒");
    }

    /**
     * 第二种调用定时方案  只需调用该方法即可
     */
    public void checkorderExpireInfoByScheduled() {
        //延时推送检查  第一次1小时检查，第二次/以后每十二小时检查一次
        executorService.
                scheduleAtFixedRate(new OrderActiveThread(), 1, 12, TimeUnit.HOURS);
    }

    class OrderActiveThread implements Runnable {

        @Override
        public void run() {
            long startTime = System.currentTimeMillis();
            System.out.println("开始扫描时间 startTime = " + startTime);
            List<OrderInfo> orderInfoExpireList = orderInfoService.getOrderInfoExpireList();
            for (OrderInfo orderInfo : orderInfoExpireList) {
                System.out.println("扫描完成");
                orderInfoService.setOrderStatus(orderInfo);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("扫描用了" + (endTime - startTime) + " 毫秒");
        }
    }

    public void setOrderInfoService(OrderInfoService orderInfoService) {
        this.orderInfoService = orderInfoService;
    }

    public void setExecutorService(ScheduledExecutorService executorService) {
        this.executorService = executorService;
    }
}