自定义线程安全缓存

自定义线程安全缓存

话不多说，直接上代码

package lockDemo;

import java.util.HashMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author : fzz
 */
public class MapCache {
    private static volatile HashMap<Object , Object> map = new HashMap<>();

    private static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public Object getCache(Object obj){
        rwl.readLock().lock();
        Object value = null;
        try{
            value = map.get(obj);
            if (value == null){
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try{
                    if (value == null){
                        value = "fzz";
                        map.put(obj,value);
                    }
                }catch(Exception e){
                    System.out.println("Cache Exception read data :"+e.getMessage());
                }finally{
                    rwl.writeLock().unlock();
                    rwl.readLock().lock();
                }
            }
        }catch (Exception e){
            System.out.println("Cache Exception :"+e.getMessage());
        } finally {
            rwl.readLock().unlock();
        }
        return value;
    }

    public Boolean putCache(Object key, Object value){
        rwl.writeLock().lock();
        try{
            map.put(key,value);
            //  存入数据库
        }catch (Exception e){
            System.out.println("Cache Exception :"+e.getMessage());
        }finally{
            rwl.writeLock().unlock();
        }
        return true;
    }

}

package lockDemo;

import java.util.Random;
import java.util.concurrent.*;

/**
 * @author : fzz
 */
public class LockTest {
    /**
     * 自定义线程池
     *  corePoolSize：指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
     *  maximumPoolSize:指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
     * keepAliveTime:当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；
     * unit:keepAliveTime的单位
     * workQueue:任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、*任务队列、优先任务队列几种；
     */
    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,100,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(10));

    public static void main(String[] args) {
        for (int i = 0 ; i < 10 ; i++){
            final int j = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    MapCache mapCache = new MapCache();
                    mapCache.putCache(String.valueOf("fzz"+j),String.valueOf("cst"+j));
                }
            });
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    MapCache mapCache = new MapCache();
                    System.out.println("cst"+j+":"+mapCache.getCache("cst"+j));
                }
            });
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    MapCache mapCache = new MapCache();
                    System.out.println("fzz"+j+":"+mapCache.getCache("fzz"+j));
                }
            });
        }
        /**
         * 将线程池状态置为SHUTDOWN,并不会立即停止：
         * 停止接收外部submit的任务
         * 内部正在跑的任务和队列里等待的任务，会执行完
         * 等到第二步完成后，才真正停止
         */
        threadPoolExecutor.shutdown();
        /**
         * 将线程池状态置为STOP。企图立即停止，事实上不一定：
         * 跟shutdown()一样，先停止接收外部提交的任务
         * 忽略队列里等待的任务
         * 尝试将正在跑的任务interrupt中断
         * 返回未执行的任务列表
         */
//        threadPoolExecutor.shutdownNow();
    }

}