本文实例为大家分享了Java单例模式利用HashMap实现缓存数据的具体代码，供大家参考，具体内容如下
一、单例模式是什么？
单例模式是一种对象创建模式，它用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。Java 里面实现的单例是一个虚拟机的范围，因为装载类的功能是虚拟机的，所以一个虚拟机在通过自己的 ClassLoad 装载实现单例类的时候就会创建一个类的实例。在 Java 语言中，这样的行为能带来两大好处：
1.对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
2.由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。
因此对于系统的关键组件和被频繁使用的对象，使用单例模式可以有效地改善系统的性能。单例模式的核心在于通过一个接口返回唯一的对象实例。首要的问题就是要把创建实例的权限收回来，让类自身来负责自己类的实例的创建工作，然后由这个类来提供外部可以访问这个类实例的方法
二、单例模式结合HashMap实现缓存
1.测试结果
2.代码如下
JavaBean
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
public class People {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this .name = name; }
public int getAge() { return age; }
public void setAge( int age) { this .age = age; }
@Override public String toString() { return "People{" + "name='" + name + '\ '' + ", age=" + age + '}' ; } } |
缓存工具类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
import java.util.HashMap; import java.util.Map;
public class CacheSingletonUtil {
private static volatile CacheSingletonUtil cacheSingletonUtil; private static Map<String,Object> cacheSingletonMap;
public static final String PEOPLE_LIST_KEY = "peopleList" ;
private CacheSingletonUtil(){ cacheSingletonMap = new HashMap<String, Object>(); }
/* * 单例模式有两种类型 * 懒汉式：在真正需要使用对象时才去创建该单例类对象 * 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用 */
// 懒汉式单例模式 public static CacheSingletonUtil getInstance(){ if (cacheSingletonUtil == null ){ // 线程A和线程B同时看到cacheSingletonUtil = null，如果不为null，则直接返回cacheSingletonUtil synchronized (CacheSingletonUtil. class ) { // 线程A或线程B获得该锁进行初始化 if (cacheSingletonUtil == null ) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支 cacheSingletonUtil = new CacheSingletonUtil(); } } } return cacheSingletonUtil; }
/** * 添加到内存 */ public void addCacheData(String key,Object obj){ cacheSingletonMap.put(key,obj); }
/** * 从内存中取出 */ public Object getCacheData(String key){ return cacheSingletonMap.get(key); }
/** * 从内存中清除 */ public void removeCacheData(String key){ cacheSingletonMap.remove(key); }
} |
测试类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
import org.apache测试数据mons.collections.CollectionUtils; import java.util.ArrayList; import java.util.List;
public class CacheSingletonTest {
public static void main(String[] args) { //测试查询 testQuery(); }
private static void testQuery () { System.out.println( "第一次查询开始" ); query(); System.out.println( "第一次查询结束" );
System.out.println( "=============" );
System.out.println( "第二次查询开始" ); query(); System.out.println( "第二次查询结束" ); }
/* * 查询数据 */ private static List<People> query() { List<People> peopleList = null ;
List<People> cacheData = (List<People>) CacheSingletonUtil.getInstance().getCacheData(CacheSingletonUtil.PEOPLE_LIST_KEY);
if (CollectionUtils.isNotEmpty(cacheData)) { System.out.println( "从内存中读取" ); peopleList = cacheData; } else { System.out.println( "从数据库中读取" ); peopleList = getData(); // 添加到内存中 CacheSingletonUtil.getInstance().addCacheData(CacheSingletonUtil.PEOPLE_LIST_KEY, peopleList); }
for (People people : peopleList) { System.out.println( "name : " + people.getName() + " age : " + people.getAge()); }
return peopleList; }
/* * 删除数据 */ private void deleteCache () { CacheSingletonUtil.getInstance().removeCacheData(CacheSingletonUtil.PEOPLE_LIST_KEY); }
private static List<People> getData() { People p1 = new People(); p1.setName( "Jack" ); p1.setAge( 25 );
People p2 = new People(); p2.setName( "Brown" ); p2.setAge( 28 );
List<People> peopleList = new ArrayList<>(); peopleList.add(p1); peopleList.add(p2);
return peopleList; } } |
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
原文链接：https://blog.csdn.net/yang353933546/article/details/108296693
查看更多关于Java单例模式利用HashMap实现缓存数据的详细内容...