Android 单例实现的三种方式

最新推荐文章于 2025-07-09 09:45:17 发布

原创最新推荐文章于 2025-07-09 09:45:17 发布 · 404 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了Java中四种常见的单例模式实现方式：饿汉式、懒汉式、静态内部类和双重检查。饿汉式在类加载时就完成了实例化，线程安全但不延迟加载。懒汉式在首次调用getInstance()时创建实例，线程安全但效率较低。静态内部类方式在保证线程安全的同时，实现了延迟加载和高效率。双重检查在确保线程安全的前提下，通过双重判断减少同步开销，实现了延迟加载。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、单例实现方式：饿汉式

/**
 * 饿汉式 
 * @author jojo
 */
public class SingleOne {
    // 类的静态成员变量只初始化一次，天然是线程安全的  
    private static final SingleOne instance = new SingleOne();
    private SingleOne(){}
   
    public static SingleOne getInstance(){
        return instance;
    }
}

二、单例实现方式：懒汉式

/**
 * 懒汉式
 * @author jojo
 */
public class SingleTwo {
    private static SingleTwo instance = null;
    private SingleTwo(){}
    public static synchronized SingleTwo getInstance(){
        if(instance == null) {
            instance = new SingleTwo();
        }
        return instance;
    }
    
}

三、单例实现方式：静态内部类

/**
 * 静态内部类实现方式（也是一种懒加载方式） 
 * 这种方式：线程安全，调用效率高，并且实现了延迟加载 
 * @author visiontalk
 */
public class SingleThree {
    //静态内部类方式
    private static class SingleThreeInstance {
        private static final SingleThree instance = new SingleThree();
    }
    
    public static SingleThree getIntance(){
        return SingleThreeInstance.instance;
    }
    
    private SingleThree(){
        System.out.println("SingleThree");
    }
    
}

四、单例实现方式：双重检测

/**
 * 双重检测
 * @author visiontalk
 */
public class SingleFour {
    private volatile static SingleFour instance = null;
    
    private SingleFour(){}
    
    public SingleFour getInstance(){
        if(instance == null){
            synchronized(SingleFour.class){
                if(instance == null) {
                    instance = new SingleFour();
                }
            }
        }
        
        return instance;
    }
    
}