文章目录
  1. 1. 传统的单例模式—懒汉模式
  2. 2. 传统的单例模式—饿汉模式
  3. 3. 代码实现
  • 小结
  • 说到单例模式,想必各位小伙伴都能够不假思索的挥手写一段出来。并且能对其分类有所理解。

    传统的单例模式—懒汉模式

    public class Singleton{
    
        private static final Singleton singleton = null;
    
        private Sinleton(){}
    
        public Singleton getSingletonInstance() {
            if(singleton == null) {
                singleton = new Sinleton();
            }
            return sinleton;
        }
    
        public static void otherMethod(){}
    }
    

    传统的单例模式—饿汉模式

    public class Singleton{
    
        private static final Singleton singleton = new Sinleton();
    
        private Sinleton(){}
    
        public Singleton getSingletonInstance() {
            return sinleton;
        }
    
        public static void otherMethod(){}
    }
    

    这里要指出的是,单例模式的应用场景:一般对只需要加载一次的对象使用单例模式进行加载,有时候为了调用单例类中的某个方法不需要对整个单例进行类加载,而且上述的懒汉模式存在线程不安全问题,为了避免上述的问题,我们引入静态内部类进行解决,完成单例的懒加载(延迟加载)。

    类级内部类相当于其外部类的static成员,它的对象与外部类对象间不存在依赖关系,
    相互独立,因此可直接创建。而对象级内部类的实例,是必须绑定在外部对象实例上的。
    类级内部类只有在第一次被使用的时候才被会装载。
    
    要想很简单地实现线程安全,可以采用静态初始化器的方式,它可以由JVM来保证线程的安全性,
    如饿汉式单例,这种实现方式,会在类装载的时候就初始化对象,有可能浪费一定的内存(假设你不需要的话),
    有一种方法能够让类装载的时候不去初始化对象,就是采用类级内部类,在这个类级内部类里面去创建对象实例。
    

    代码实现

    public class Singleton {
    
        private Singleton() {
            System.out.println("单例创建成功");
        }
    
        private static class InnerSingleton {
            private static final Singleton singletonInstance = new Singleton();
        }
    
        public static Singleton getSingletonInstance() {
            return InnerSingleton.singletonInstance;
        }
    
        public static void otherMethod() {
            System.out.println("其他方法执行");
        }
    
        public static void main(String[] args) {
            Singleton.otherMethod();
        }
    }
    

    小结

    当getSingletonInstance方法第一次被调用的时候,它第一次读取InnerSingleton.singletonInstance,内部类InnerSingleton类得到初始化;

    而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建singletonInstance的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。

    这个模式的优势在于,getSingletonInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。

    文章目录
    1. 1. 传统的单例模式—懒汉模式
    2. 2. 传统的单例模式—饿汉模式
    3. 3. 代码实现
  • 小结
  • Fork me on GitHub