So verwenden Sie HashMap zum Zwischenspeichern von Daten im Java-Singleton-Modus

1. Was ist das Singleton-Muster?

Der Singleton-Modus ist ein Objekterstellungsmodus, der zum Generieren einer bestimmten Instanz eines Objekts verwendet wird. Er kann sicherstellen, dass eine Klasse im System nur eine Instanz generiert. Der in Java implementierte Singleton liegt im Bereich einer virtuellen Maschine. Da die Funktion zum Laden einer Klasse zur virtuellen Maschine gehört, erstellt eine virtuelle Maschine eine Instanz der Klasse, wenn sie die Singleton-Klasse über ihr eigenes ClassLoad lädt. In der Java-Sprache kann ein solches Verhalten zwei große Vorteile bringen:

1 Bei häufig verwendeten Objekten kann der Zeitaufwand für die Erstellung von Objekten entfallen. Dies ist ein sehr erheblicher Systemaufwand.

2. Da die Anzahl neuer Vorgänge reduziert wird, wird auch die Häufigkeit der Systemspeichernutzung verringert, was den GC-Druck verringert und die GC-Pausenzeit verkürzt.

Daher kann die Verwendung des Singleton-Musters für Schlüsselkomponenten des Systems und häufig verwendete Objekte die Leistung des Systems effektiv verbessern. Der Kern des Singleton-Musters besteht darin, eine eindeutige Objektinstanz über eine Schnittstelle zurückzugeben. Das erste Problem besteht darin, die Berechtigung zum Erstellen von Instanzen zurückzunehmen, die Klasse selbst für das Erstellen von Instanzen ihrer eigenen Klasse verantwortlich zu machen und diese Klasse dann externe Methoden für den Zugriff auf Instanzen dieser Klasse bereitstellen zu lassen

2 . Singleton-Modus kombiniert mit HashMap zur Implementierung von Caching

1 Testergebnisse

# 🎜🎜 #2. Der Code lautet wie folgt

JavaBean

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 +
                '}';
    }
}

Caching Tool Class

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);
    }

}

Test Class

import org.apache.commons.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;
    }
}

Das obige ist der detaillierte Inhalt vonSo verwenden Sie HashMap zum Zwischenspeichern von Daten im Java-Singleton-Modus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!