Java多线程-缓存框架

最新推荐文章于 2024-05-10 11:26:21 发布
最新推荐文章于 2024-05-10 11:26:21 发布
阅读量325 收藏
点赞数
分类专栏： Java基础多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxssbsb/article/details/117234399
版权
本文探讨了从简单HashMap缓存到高级解决方案，如装饰者模式、ConcurrentHashMap和Future，如何解决并发安全、重复计算及异常处理等问题。通过实例展示了缓存优化和线程同步的最佳实践。
摘要由CSDN通过智能技术生成

缓存框架

1、使用HashMap实现一个缓存

/**
 * @Classname ImocCache1
 * @Description 最简单的缓存形式，HashMap
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache1 {

    private HashMap<String, Integer> cache = new HashMap<>();

    public Integer computer(String userId) throws InterruptedException {
        Integer result = cache.get(userId);
        //先检查hashmap中是否有这个缓存
        if (result == null){
            //如果缓存中找不到，需要重新计算一下结果，然后保存到cache中
            result = doCompute(userId);
            cache.put(userId, result);
        }
        return result;
    }

    public Integer doCompute(String userId) throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        return new Integer(userId);
    }

    public static void main(String[] args) throws InterruptedException {
        ImocCache1 imocCache1 = new ImocCache1();
        System.out.println("开始计算了");
        Integer result = imocCache1.computer("13");
        System.out.println("第一次计算的结果"+result);
        result = imocCache1.computer("13");
        System.out.println("第二次计算的结果"+result);

    }
}

多个线程同时进来，会有并发安全问题，且代码耦合

2、用装饰者模式来解决解耦的问题

/**
 * @Classname Computable
 * @Description 有一个计算函数computer，用来代表耗时计算，每个计算器都要实现这个接口，这样就
 * 可以无侵入实现缓存的功能
 * @Date 2021/5/24 22:56
 * @Created by WangXiong
 */
public interface Computable<A, V> {
     V computer(A arg) throws Exception;
}
/**
 * @Classname ExpensiveFuntion
 * @Description 耗时计算的实现类，实现了Computable接口，但是本身不具备缓存能力，不需要考虑
 * 缓存的事情
 * @Date 2021/5/24 22:58
 * @Created by WangXiong
 */
public class ExpensiveFunction implements Computable<String, Integer>{

    @Override
    public Integer computer(String arg) throws Exception {
        Thread.sleep(5000);
        return Integer.valueOf(arg);
    }
}
/**
 * @Classname ImocCache1
 * @Description 用装饰者模式，给计算器自动添加缓存功能
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache2<A, V> implements Computable<A, V> {

    private HashMap<A, V> cache = new HashMap<>();

    private final Computable<A, V> c;

    public ImocCache2(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        System.out.println("进入缓存机制");
        V result = cache.get(arg);
        if (result == null){
            result =  c.computer(arg);
            cache.put(arg, result);
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        ImocCache2<String, Integer> exImocCache2 = new ImocCache2<>(new ExpensiveFunction());
        Integer result = exImocCache2.computer("666");
        System.out.println("第一次计算结果"+result);
        result = exImocCache2.computer("666");
        System.out.println("第二次计算结果"+result);
    }
}

 3、多线程中会有线程安全问题

使用synchronize来处理线程安全问题

/**
 * @Classname ImocCache1
 * @Description 演示synchronized的问题，导致性能差，没有办法多个线程同时访问缓存
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache3<A, V> implements Computable<A, V> {

    private HashMap<A, V> cache = new HashMap<>();

    private final Computable<A, V> c;

    public ImocCache3(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    //由于加上了synchronized，这个方法同时只能一个线程访问，效率低下
    public synchronized V computer(A arg) throws Exception {
        System.out.println("进入缓存机制1");
        V result = cache.get(arg);
        if (result == null){
            result =  c.computer(arg);
            cache.put(arg, result);
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        ImocCache3<String, Integer> exImocCache2 = new ImocCache3<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

4、降低synchronize粒度

将synchronize的粒度降低，让线程性能提高，但是这样依旧会有性能问题。

/**
 * @Classname ImocCache1
 * @Description 使用synchronized缩小粒度，提高性能，但是依旧是线程不安全的
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache4<A, V> implements Computable<A, V> {

    private HashMap<A, V> cache = new HashMap<>();

    private final Computable<A, V> c;

    public ImocCache4(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        System.out.println("进入缓存机制1");
        //读的时候也会有线程安全的问题
        V result = cache.get(arg);
        if (result == null){
            result =  c.computer(arg);
            synchronized (this) {
                cache.put(arg, result);
            }
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        ImocCache4<String, Integer> exImocCache2 = new ImocCache4<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

5.使用线程安全的HashMap

/**
 * @Classname ImocCache1
 * @Description 使用ConcurrentHashMap优化缓存
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache5<A, V> implements Computable<A, V> {

    private ConcurrentHashMap<A, V> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache5(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        System.out.println("进入缓存机制1");
        //读的时候也会有线程安全的问题
        V result = cache.get(arg);
        if (result == null){
            result =  c.computer(arg);
            cache.put(arg, result);
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        ImocCache5<String, Integer> exImocCache2 = new ImocCache5<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

6、解决缓存值重复计算的问题

演示值计算多遍的问题

/**
 * @Classname ImocCache1
 * @Description 使用ConcurrentHashMap优化缓存，还是会有问题，会有计算多遍的问题
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache6<A, V> implements Computable<A, V> {

    private ConcurrentHashMap<A, V> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache6(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        System.out.println("进入缓存机制1");
        V result = cache.get(arg);
        if (result == null){
            //计算是耗时的，第二个线程过来还没有算好，也会去进行计算
            result =  c.computer(arg);
            cache.put(arg, result);
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        ImocCache6<String, Integer> exImocCache2 = new ImocCache6<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

效果

使用Future来解决重复计算的问题

/**
 * @Classname ImocCache1
 * @Description 使用Future来解决重复计算的问题
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache7<A, V> implements Computable<A, V> {

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache7(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        Future<V> f = cache.get(arg);
        if (f == null) {
            Callable<V> callable = new Callable<V>() {

                @Override
                public V call() throws Exception {
                    return c.computer(arg);
                }
            };
            FutureTask<V> ft = new FutureTask<>(callable);
            f = ft;
            cache.put(arg, ft);
            System.out.println("从FutureTask调用了计算函数");
            ft.run();
        }

        return f.get();
    }

    public static void main(String[] args) throws Exception {
        ImocCache7<String, Integer> exImocCache2 = new ImocCache7<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

效果

我们调整下线程之间的顺序，依旧会出现重复计算的问题。因为在第一个线程还没有put进去的时候，第二个线程就去get了，这个时候也会认为是没有计算的，一旦进入到if中，就一定回去进行计算。可以使用ConcurrentHashMap提供的方法来解决这个问题，因为ConcurrentHashMap的方法都是线程安全的，所以不用考虑线程安全问题

/**
 * @Classname ImocCache1
 * @Description 使用Future依旧会出现一定几率的重复计算，
 * 使用ConcurrentHashMap的提供的方法putIfAbsent()进行避免
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache8<A, V> implements Computable<A, V> {

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache8(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws Exception {
        Future<V> f = cache.get(arg);
        if (f == null) {
            Callable<V> callable = new Callable<V>() {

                @Override
                public V call() throws Exception {
                    return c.computer(arg);
                }
            };
            FutureTask<V> ft = new FutureTask<>(callable);
            //putIfAbsentr如果存在arg的key的数据，就不会进行put操作，如果为空，会返回null
            f = cache.putIfAbsent(arg, ft);
            if (f == null) {
                f = ft;
                System.out.println("从FutureTask调用了计算函数");
                ft.run();
            }

        }

        return f.get();
    }

    public static void main(String[] args) throws Exception {
        ImocCache8<String, Integer> exImocCache2 = new ImocCache8<>(new ExpensiveFunction());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

7、给缓存类增加异常处理的能力

/**
 * @Classname ImocCache1
 * @Description 给缓存类增加异常处理的能力
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache9<A, V> implements Computable<A, V> {

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache9(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws InterruptedException, ExecutionException {
        while (true) {
            Future<V> f = cache.get(arg);
            if (f == null) {
                Callable<V> callable = new Callable<V>() {

                    @Override
                    public V call() throws Exception {
                        return c.computer(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<>(callable);
                //putIfAbsentr如果存在arg的key的数据，就不会进行put操作，如果为空，会返回null
                f = cache.putIfAbsent(arg, ft);
                if (f == null) {
                    f = ft;
                    System.out.println("从FutureTask调用了计算函数");
                    ft.run();
                }

            }
            try {
                return f.get();
            } catch (CancellationException e) {
                System.out.println("被取消了");
                cache.remove(arg);
                throw e;
            } catch (InterruptedException e) {
                System.out.println("被中断了");
                cache.remove(arg);
                throw e;
            } catch (ExecutionException e) {
                System.out.println("计算错误，需要重试");
                //异常了，一定要删除缓存数据，不然会有污染数据，导致一直重试
                cache.remove(arg);
            }
        }

    }

    public static void main(String[] args) throws Exception {
        ImocCache9<String, Integer> exImocCache2 = new ImocCache9<>(new MayFail());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        // Thread.sleep(3000);
        // Future<Integer> future = exImocCache2.cache.get("666");
        // future.cancel(false);
    }
}

8、 给缓存类增加过期功能

/**
 * @Classname ImocCache1
 * @Description 给缓存类增加缓存过期的功能
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache10<A, V> implements Computable<A, V> {

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();

    private final Computable<A, V> c;

    public ImocCache10(Computable<A, V> c) {
        this.c = c;
    }

    @Override
    public V computer(A arg) throws InterruptedException, ExecutionException {
        while (true) {
            Future<V> f = cache.get(arg);
            if (f == null) {
                Callable<V> callable = new Callable<V>() {

                    @Override
                    public V call() throws Exception {
                        return c.computer(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<>(callable);
                //putIfAbsentr如果存在arg的key的数据，就不会进行put操作，如果为空，会返回null
                f = cache.putIfAbsent(arg, ft);
                if (f == null) {
                    f = ft;
                    System.out.println("从FutureTask调用了计算函数");
                    ft.run();
                }

            }
            try {
                return f.get();
            } catch (CancellationException e) {
                System.out.println("被取消了");
                cache.remove(arg);
                throw e;
            } catch (InterruptedException e) {
                System.out.println("被中断了");
                cache.remove(arg);
                throw e;
            } catch (ExecutionException e) {
                System.out.println("计算错误，需要重试");
                //异常了，一定要删除缓存数据，不然会有污染数据，导致一直重试
                cache.remove(arg);
            }
        }

    }

    public final ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
    //为避免缓存雪崩，写一个产生随机值的缓存时间的方法
    public V computerRandomExpire(A arg) throws ExecutionException, InterruptedException {
        long randomExpire = (long) (Math.random() * 10000);
        System.out.println("computerRandomExpire设置的缓存时间:"+randomExpire);
        return computer(arg, randomExpire);
    }
    public V computer(A arg, long expire) throws ExecutionException, InterruptedException {
        //设置相同的缓存失效时间，会造成缓存雪崩
        service.schedule(new Runnable() {
            @Override
            public void run() {
                expire(arg);
            }
        }, expire, TimeUnit.MILLISECONDS);
        return computer(arg);
    }

    public synchronized void expire(A key){
        Future<V> future = cache.get(key);
        if (future != null) {
            if (!future.isDone()){
                System.out.println("Future任务被取消");
                future.cancel(true);
            }
            System.out.println("过期时间到，缓存被清除");
            cache.remove(key);
        }
    }

    public static void main(String[] args) throws Exception {
        ImocCache10<String, Integer> exImocCache2 = new ImocCache10<>(new MayFail());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computerRandomExpire("666");
                    System.out.println("第一个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第二个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("777");
                    System.out.println("第三个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        // Thread.sleep(3000);
        // Future<Integer> future = exImocCache2.cache.get("666");
        // future.cancel(false);

        Thread.sleep(7000l);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer result = exImocCache2.computer("666");
                    System.out.println("第四个线程end"+result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

9、 测试缓存性能

/**
 * @Classname ImocCache1
 * @Description 测试环境耗时
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache11<A, V> {

    static ImocCache10<String, Integer> imocCache10 = new ImocCache10<>(new ExpensiveFunction());
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(3000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 3000; i++) {
            service.submit(()->{
                try {
                    imocCache10.computer("666");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            });
        }
        service.shutdown();
        while (!service.isTerminated()){

        }
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
    }
}

借助CountDownLatch来实现压测的效果

/**
 * @Classname ImocCache1
 * @Description 测试环境耗时
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache11<A, V> {

    static ImocCache10<String, Integer> imocCache10 = new ImocCache10<>(new ExpensiveFunction());
    public static final CountDownLatch countDownLatch = new CountDownLatch(1);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(3000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 3000; i++) {
            service.submit(()->{
                try {
                    System.out.println(Thread.currentThread().getName() + "开始等待");
                    countDownLatch.await();
                    Integer result = imocCache10.computer("666");
                    System.out.println(Thread.currentThread().getName() + "结束等待");
                    System.out.println(result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            });
        }

        Thread.sleep(5000);
        countDownLatch.countDown();
        service.shutdown();

    }
}

每个线程都打印自己的时间，用ThreadLocal来实现

/**
 * @Classname ImocCache1
 * @Description 测试环境耗时，使用ThreadLocal线程来存储变量
 * @Date 2021/5/24 22:44
 * @Created by WangXiong
 */
public class ImocCache11<A, V> {

    static ImocCache10<String, Integer> imocCache10 = new ImocCache10<>(new ExpensiveFunction());
    public static final CountDownLatch countDownLatch = new CountDownLatch(1);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(3000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 3000; i++) {
            service.submit(()->{
                try {
                    System.out.println(Thread.currentThread().getName() + "开始等待");
                    countDownLatch.await();
                    SimpleDateFormat dateFormat = ThreadSafeFormatter.dft.get();
                    String format = dateFormat.format(new Date());
                    Integer result = imocCache10.computer("666");
                    System.out.println(Thread.currentThread().getName() + "    " + format + "被放行");
                    // System.out.println(result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            });
        }

        Thread.sleep(5000);
        countDownLatch.countDown();
        service.shutdown();

    }
}

class ThreadSafeFormatter {
    public static ThreadLocal<SimpleDateFormat> dft = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("mm:ss");
        }

        @Override
        public SimpleDateFormat get() {
            return super.get();
        }
    };
}

10、总结

用HashMap作为缓存进行迭代

用synchronize来解决线程安全问题，但是会影响性能

用装饰者模式来解决代码侵入的问题，重复的代码可以进行复用

将类锁的synchronize换为粒度更小的代码块，但是依旧会有线程安全问题

使用ConcurrentHashMap线程安全的map来解决，但是在一定的情况下依旧是线程不安全，并且会有重复计算的问题

使用Future来解决重复计算的问题，并且用ConcurrentHashMap提供的线程安全的方法来解决上面一定情况下线程不安全的情况

增加异常处理，对取消和中断做不同的处理，对计算错误可以进行重试（需要在计算失败的时候，进行缓存移除，不然会有缓存污染问题）

需要增加缓存过期问题，对缓存时间设置的不一致，设置随机值 ，避免雪崩

利用CountDownLatch来进行压测

使用ThreadLocal来处理打印时间的问题

 

Wan9_Xion9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程缓存_多线程同时加载缓存实现
weixin_30212109的博客
02-15 530
import com.google.common.cache.Cache;import com.google.common.cache.CacheBuilder;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent....
java多线程缓存_java – 线程的多线程访问和变量缓存
weixin_39900736的博客
02-15 439
问题是java只是一个规范.有许多JVM实现和物理操作环境的示例.在任何给定的组合上,动作可能是安全的或不安全的.例如,在单处理器系统上,示例中的volatile关键字可能完全没必要.由于存储器和语言规范的编写者无法合理地考虑可能的操作条件集,因此他们选择将某些模式列入白名单,这些模式可以保证适用于所有兼容的实现.遵守这些准则可确保您的代码可以在目标系统上运行,并且可以合理地移植.在这种情况下,“...
Java最全Java多线程之Executor框架(1)，和阿里大佬的技术面谈
最新发布
2401_84689803的博客
05-10 879
这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。你的支持，我的动力；祝各位前程似锦，offer不断！！！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取② 线程缺乏管理。
Java的多线程机制:缓存一致性和CAS
weixin_34025151的博客
11-05 319
2019独角兽企业重金招聘Python工程师标准>>> ...
java 多线程写缓存,Java多线程_缓存对齐
weixin_31967737的博客
03-20 267
1.什么是缓存对齐当前的电脑中，数据存储在磁盘上，可以断电保存，但是读取效率较低。不断电的情况下，数据可以在内存中存储，相对硬盘效率差不多是磁盘的一万倍左右。但是运算时，速度最快的是直接缓存在CPU中的数据。CPU有三级缓存分别是L1,L2,L3三级，CPU访问速度大概是内存的100倍。1.1CPU结构对于一台电脑，其主板可以支持多少个CPU插槽，称为CPU个数。对于一颗多核CPU，单片CPU上集...
Java多线程缓存器简单实现
amyzhang1234的博客
07-19 162
package com.charles.utils; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; public class CharlesCache { private Map<St...
Java多线程-JDK5.0新增线程创建方式
02-03
### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1：实现Callable接口 ##### （1）介绍 自Java 5.0起，为提高线程管理的灵活性与效率，引入了`Callable`接口，这是一种全新的创建线程的方式。与传统的`...
基于Java的源码-分布式缓存框架 SwarmCache.zip
07-23
SwarmCache是一个基于Java实现的分布式缓存框架，它的设计目标是提供一个简单、高效且易于扩展的解决方案。本文将深入探讨SwarmCache的核心概念、设计原理以及在实际开发中的应用。 首先，SwarmCache的设计理念源自...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
例如，分布式计算框架如Hadoop和Spark就是利用多线程和分布式处理来实现大规模数据的并行计算。同时，设计良好的并发模型还能减少响应时间，提高用户体验。 综上所述，这个压缩包很可能包含了一些关于如何在AI项目...
基于Java的源码-Ehcache Java 缓存框架.zip
07-15
Ehcache是一个广泛使用的开源Java缓存框架，它在Java应用程序中提供了高效的缓存功能，以提高性能并减少对数据库的依赖。这个压缩包“基于Java的源码-Ehcache Java 缓存框架.zip”很可能包含了Ehcache的源代码，使得...
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
优化版的环形缓存器 线程安全 生产者消费者模式
12-15
之前上传过一个环形缓存器（这是一个基本的生产者消费者模式的环形缓存器，具有线程安全性，可同时写入和读取，非装箱拆箱操作，高性能大数据可使用此缓存器。），这个是优化版，增加了缓存器满的标志位，优化了内存复制部分，性能更好，使用时需要注意，如果是多生产者多消费者需要在POP和PUSH中增加互斥锁，不过会导致性能下降，最后吐槽一下，自己上传的的东西不能删除······
Java多线程-模拟一个缓存代理
魂-淡
08-27 293
示例 package com.zhihua.subject; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * 缓存...
java 多线程写缓存_Java多线程学习笔记之二缓存
weixin_39747293的博客
02-16 445
1、高速缓存由来：处理器处理能力原因大于主内存(DRAM)访问速率，为了弥补这个差距，引入了高速缓存。高速缓存是一种存取速率远比主内存大而容量远比主内存小的存储部件，每一个处理器都有其高速缓存。在引入高速缓存之后，处理器执行读、写操作时就不直接操作主内存，而是通过高速缓存执行的。变量名相当于内存地址，变量值相当于相应内存空间中存储的数据。可以理解为，高速缓存为程序中的数据做了一份对应主内存的副本，...
java多线程—cpu缓存
云舒编程的博客
05-23 1160
CPU缓存网页浏览器为了加快速度,会在本机存缓存以前浏览过的数据; 传统数据库或NoSQL数据库为了加速查询, 常在内存设置一个缓存, 减少对磁盘(慢)的IO. 同样内存与CPU的速度相差太远, 于是CPU设计者们就给CPU加上了缓存(CPU Cache). 如果你需要对同一批数据操作很多次, 那么把数据放至离CPU更近的缓存, 会给程序带来很大的速度提升. 例如, 做一个循环计数, 把计数变量放到
设计一个缓存系统  java多线程读写锁的应用
空山清泉明月
03-23 2765
高并发多线程读写锁的应用
【多线程】-cpu-Cache模型和java内存模型（全面解析）
知识追寻者(Inheriting the spirit of open source, Spreading technology knowledge;)
11-05 293
你的模样好特别，好抽象，在夜深人静的时候，总会想起黄昏下我与你擦肩而过的背影；
java 缓存_Java多线程——CPU缓存原理和缓存一致性问题
weixin_39794213的博客
12-02 163
说起Java中的多线程，就不得不说volatile关键词volatile关键词执行修饰变量和实例变量，不能修饰方法参数，局部变量和实例常量。volatile是Java提供的一种轻量级的同步机制，在并发编程中，它是担任了重要的角色。同synchronized相比（synchronized通常称为重量级锁），volatile更轻量级。想要了解votatile的来龙去脉，就必须了解CPU缓存模型和jav...
LRU（多线程）缓存的实现
qq_32459653的博客
09-20 2891
前面写了个lru缓存，适用于单线程的场景。多线程实现缓存的思路有很多种，有基于ttl淘汰策略的，有基于lru淘汰实现的，而在淘汰的方式也有很多选择，如果选用Concurrenthashmap,可以很好的基于ttl淘汰策略，具体实现是另开一个守护线程，定时淘汰ConcurrenthashMap中的过期键，而在使用lru淘汰策略时则需要额外借助辅助结构双向链表，需要额外的同步操作，由于在本文之前实现了...
Java面试深度解析：集合框架、HashMap原理、多线程与缓存技术
"这篇Java面试复习攻略涵盖了广泛的Java技术和概念，包括集合框架、HashMap底层原理、多线程、消息队列、Redis、Spring-Boot以及Spring-Cloud技术。" 在Java编程中，集合框架是核心部分，它由Collection和Map两大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值