Java并发工具之实战高性能缓存

素颜马尾好姑娘i 2023-07-16 07:57 2阅读 0赞

## 1. 最简单的缓存：HashMap实现 ##

*  最简单的缓存代码如下：

public class Cache1 { 
        //cache属性被声明为final后，该变量只能被赋值一次（但是内部可以添加删除多次），
        // 增强安全性，在语义上表名这是一个缓存，引用赋值之后就不再改变了；
        private final HashMap<String, Integer> cache =  new HashMap<>();
    
        public Integer doCache(String userId) throws InterruptedException { 
            Integer result = cache.get(userId);
            //先检查HashMap里面有没有保存过之前的计算结果
            if (result == null) { 
                //如果缓存中找不到，那么需要现在计算一下结果，并且保存到HashMap中
                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 { 
            Cache1 cache1 = new Cache1();
            System.out.println("开始计算了");
            Integer result = cache1.doCache("10");
            System.out.println("第一次计算结果：" + result);
            result = cache1.doCache("10");
            System.out.println("第二次运算结果：" + result);
    
        }
    }

开始计算了
    第一次计算结果：10
    第二次运算结果：10

*  **线程安全问题**，当多个线程竞争访问的时候，可能导致HashMap同时造成扩容导致的结果错误的情况，因为HashMap是线程不安全的，而且compute方法也不是线程安全的，针对这些问题，可以通过加synchronized关键字来解决，但是性能太差；
 *  **重复计算问题**，当多个线程竞争访问的时候，假如多个线程都走到 if (result == null)逻辑，一个线程计算完了，还没赋值给result，另一个线程仍然判断result为null，进而重复计算result结果；
 *  **代码复用性差**， 因为在doCache方法里面调用了doCompute方法，如果有新的计算逻辑，那么也需要在缓存方法中调用，所以缓存方法和计算方法耦合性太高导致代码复用性太差；

## 2. 用装饰者模式解决代码复用性问题 ##

/** * 被装饰者接口 */
    public interface Computable { 
    
        Integer compute(String arg);
    }

/** * 被装饰者实现类，不具备缓存的能力，只负责计算结果 */
    public class ComputableImpl implements Computable { 
    
        @Override
        public Integer compute(String arg) { 
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            return Integer.valueOf(arg);
        }
    }

/** * 装饰者，持有被装饰者的引用，在被装饰者方法的前后实现缓存判断 */
    public class Cache2 implements Computable { 
    
        private final Computable computable;
    
        public Cache2(Computable computable) { 
            this.computable = computable;
        }
    
    
        private final HashMap<String, Integer> cache = new HashMap<>();
    
        @Override
        public Integer compute(String arg) { 
            Integer result = cache.get(arg);
            if (result == null) { 
                result = computable.compute(arg);
                cache.put(arg, result);
            }
            return result;
        }
    
        public static void main(String[] args) { 
            Computable computable = new ComputableImpl();
            computable = new Cache2(computable);
            System.out.println(computable.compute("11"));
            System.out.println(computable.compute("11"));
    
        }
    }

## 3. 用ConcurrentHashMap解决线程安全问题 ##

/** * 用ConcurrentHashMap解决线程安全问题 */
    public class Cache3 implements Computable { 
    
        private final Computable computable;
    
        public Cache3(Computable computable) { 
            this.computable = computable;
        }
    
    
        private final ConcurrentHashMap<String, Integer> cache = new ConcurrentHashMap<>();
    
        @Override
        public Integer compute(String arg) { 
            System.out.println("进入缓存机制");
            Integer result = cache.get(arg);
            if (result == null) { 
                result = computable.compute(arg);
                cache.put(arg, result);
            }
            return result;
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Computable computable = new ComputableImpl();
            computable = new Cache3(computable);
            Computable finalComputable = computable;
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = finalComputable.compute("1");
                    System.out.println("第一次计算结果：" + result);
                }
            }).start();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = finalComputable.compute("2");
                    System.out.println("第二次计算结果：" + result);
                }
            }).start();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = finalComputable.compute("1");
                    System.out.println("第三次计算结果：" + result);
                }
            }).start();
    
        }
    }

## 4. 用Future解决重复计算问题 ##

虽然用了装饰者模式解耦，用了ConcurrentHashMap解决了put时候的线程安全问题，但是仍然存在在某个线程的计算完成之前，另一个要求计算相同值的请求到来，会导致计算**两遍**，这和缓存想避免多次计算的初衷恰恰相反。  
我们可以用Future和Callable来解决这个问题

/** * 用Future避免重复计算 */
    public class Cache4 implements Computable { 
    
        private final Computable computable;
    
        public Cache4(Computable computable) { 
            this.computable = computable;
        }
    
    
        private final ConcurrentHashMap<String, Future<Integer>> cache = new ConcurrentHashMap<>();
    
        @Override
        public Integer compute(String arg) throws ExecutionException, InterruptedException { 
            Future<Integer> f = cache.get(arg);
            if (f == null) { 
                Callable<Integer> callable = new Callable<Integer>() { 
                    @Override
                    public Integer call() throws Exception { 
                        System.out.println("调用了计算方法");
                        return computable.compute(arg);
                    }
                };
                FutureTask<Integer> task = new FutureTask<>(callable);
                f = task;
                cache.put(arg, task);
                task.run();
            }
            return f.get();
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Computable computable = new ComputableImpl();
            computable = new Cache4(computable);
            Computable finalComputable = computable;
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = null;
                    try { 
                        result = finalComputable.compute("1");
                    } catch (ExecutionException e) { 
                        e.printStackTrace();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("第一次计算结果：" + result);
                }
            }).start();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = null;
                    try { 
                        result = finalComputable.compute("2");
                    } catch (ExecutionException e) { 
                        e.printStackTrace();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("第二次计算结果：" + result);
                }
            }).start();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    Integer result = null;
                    try { 
                        result = finalComputable.compute("1");
                    } catch (ExecutionException e) { 
                        e.printStackTrace();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("第三次计算结果：" + result);
                }
            }).start();
    
        }
    }