2020-06-12 设计模式之深入理解单例模式：静态内部类单例原理

23种设计模式之单例模式

单例模式分为: 饿汉式 懒汉式 双重锁懒汉式 静态懒汉式 静态内部类懒汉式 枚举懒汉式

---

单例模式饿汉式

class SingletonTest01{

    public static void main(String [] args){

        //测试
        Singleton inSingleton = Singleton.getInstance();
        Singleton inSingleton2 = Singleton.getInstance();
        System.out.println(inSingleton == inSingleton2);//true
        System.out.println(inSingleton.hashCode());//hashCode相同
        System.out.println(inSingleton2.hashCode());

    }

}

class Singleton{

        //1.构造器私有化，外部不能通过new来创建对象
        private Singleton(){}

        //2.本类内部创建对象实例在类加载的时候就会被创建,这里使用final是保证线程安全，final不可变对象
        private final static Singleton instance = new Singleton();

        //3.提供一个公有的静态方法，返回实例对象，通过调用方法来返回实例对象
        public static Singleton getInstance() {
                return instance;
        }
}



//输出
true
366712642
366712642

结论：
构造器私有化，外部不能通过new来实例化对象，通过getInstance方法来创建对象
优点：线程安全,以空间换取时间效率高
缺点：在类加载时对象被创建，会占用内存

---

单例模式懒汉式

class SingletonTest02{
        public static void main(String [] args){
        // 测试
        Singleton inSingleton = Singleton.getInstance();
        Singleton inSingleton2 = Singleton.getInstance();
        System.out.println(inSingleton == inSingleton2);// true
        System.out.println(inSingleton.hashCode());// hashCode相同
        System.out.println(inSingleton2.hashCode());
        }
}

class Singleton{
      //声明一个对象
      private static Singleton instance;  
      
      //构造器私有化，外部不能通过new来创建对象
      private  Singleton(){}
      
      //提供一个静态的公有方法，使用synchronize修饰加入同步处理的代码，线程安全
      public static synchronized Singleton getInstance(){
              if(instance == null){
                      instance = new Singleton();
              }
                  return instance;
      }
     
}


//输出
true
366712642
366712642

结论：
缺点：效率低，每个类在得到类的实例时候，执行getInstance（）方法都要进行同步。
优点：线程安全。

---

单例模式双重检查

class SingletonTest06{
        public static void main(String [] args){
              //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);// true
        System.out.println(instance.hashCode());// hashCode相同
        System.out.println(instance2.hashCode());
        }

}
//懒汉式（线程安全同步方法）
class  Singleton{
      
         //采用volatile修饰变量防止重序
        private static volatile Singleton instance;

        private Singleton(){}

        //提供一个静态的公有方法，加入双重代码检查，解决线程安全问题，同时解决懒加载问题
        public static Singleton getInstance(){
                  if(instance == null){
                          synchronized(Singleton.class){
                                 if(instance == null){
                                       instance = new Singleton();
                                 }
                          }
                  }
                  return instance;
        }

}

//输出
true
366712642
366712642

结论:
该单例模式采用volatile、synchronized 进行双重检查，防止了因为多线程问题产生的重序。
很好的解决了线程安全性的问题，创建对象的时候实现了懒加载效果，当需要用到时返回instance创建实例。

---

单例模式静态内部类

class SingletonTest7{
        public static void main(String [] args){
                //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);// true
        System.out.println(instance.hashCode());// hashCode相同
        System.out.println(instance2.hashCode());

        }

}

class Singleton{

        private Singleton(){}

        //静态内部类，该类中有一个静态属性
        private static class SingletonInstance{
                //静态内部类可访问外部类的特性
                private static final Singleton INSTANCE = new Singleton();

        }
        
        //提供一个静态公共方法，直接返回SingletonInstance.INSTANCE
        
      public static Singleton  getInstance(){
          
            return SingletonInstance.INSTANCE;

      }

}

//输出
true
366712642
366712642

结论:
这种方式采用了类装在的机制来保证初始化实例时只有一个线程，静态内部类方式在Singleton类被装在时并不会立即实例化，而是在需要实例化时，调用getInstance（）方法，才会装载SingletonInstance类，从而完成Singleton的实例化，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

---

单例模式枚举的方式

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
    

}
//枚举实现单例模式
enum Singleton{
    INSTANCE;//属性
    public void sayOK() {
        System.out.println("ok");
    }
}

//输出
true
366712642
366712642

结论
借助JDK1.5种添加的枚举来实现单例模式。
枚举在java中与普通类一样，都能拥有字段与方法，而且枚举实例创建是线程安全的，在任何情况下，它都是一个单例。不仅能避免多线程同步问题，而
且还能防止反序列化重新创建新的对象。

---

在使用单例模式时保持一个对象的无状态，不必创建新的引用，采取单例模式的方式的他是直接创建使用静态实例，某种情况下会减少一定的反复创建，在线程同步的情况下保持对象的无状态，单一实例。多个线程的情况下也能保证实例的唯一性。