设计模式——单例模式

知识点：单例模式——只有一个实例的类

什么是设计模式：设计模式是在大量实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考方式。

什么是单例模式：采取一定的方法保证，整个软件系统中，一个类只能存在一个对象实例

具体实现

 在这个类的内部需要实现

（1）将类的构造方法私有化，使得在在类的外部不能通过new创建该类的实例化对象

（2）在类的内部实例化唯一的对象，用private static修饰

（3）定义一个静态方法，供类的外部调用唯一的实例对象

  实现一 饿汉模式：在类加载时，对象就已经创建

//饿汉式
public class Singleton {

    //私有化构造器,这样外部的类无法调用构造方法
    private Singleton(){}

   public static String  name;

    //内部实例化类的实例
    private static Singleton instance=new Singleton();

    //私有化对象，类通过公共方法调用
    public static Singleton getInstance(){
        return  instance;
    }
}

补充：当Singleton类被加载时，会初始化static修饰的instance,静态变量被创建并且在方法区（静态区）分配内存，Singleton对象存放在堆中，静态变量存放对象的地址，之后实例对象会一直占着这段内存，当类被卸载，

静态变量才被摧毁，释放内存

另一种静态代码块机制的写法：

//饿汉式(静态代码块)
public class HungrySingleton1 {
    //1.私有化构造器
    private HungrySingleton1(){}

    //2.声明实例变量
    private static final HungrySingleton1 instance;

    //3.静态代码块中实例化
    static {
        instance=new HungrySingleton1();
    }
    //4.公共方法获得实例
    public static HungrySingleton1 getInstance(){
        return instance;
    }
}

测试：

//饿汉式
@Test
public void testHungrySingleton(){
    ExecutorService executorService= Executors.newCachedThreadPool();
    for (int i=0;i<10;i++){
        executorService.execute(new Runnable(){
            @Override
            public void run() {
                HungrySingleton1 instance=HungrySingleton1.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance);
            }
        });

    }
}

结果：


实现二 懒汉模式：调用get()方法时，实例才被创建

//懒汉式（线程安全问题）
public class Singleton {

    //私有化构造器
    private Singleton(){}

    //内部实例化类的实例
    private static Singleton instance;

    //私有化对象，类通过公共方法调用(创建，返回实例)
    public static Singleton getInstance(){
        if(instance==null) {
            instance=new Singleton();
        }
        return instance;
    }
}

    补充：当Singleton类被加载时，静态变量instance其实在方法区中已经创建并且分配内存，当第一次调用getInstance方法，初始化instance,将堆中对象实例内存的地址赋值给变量instance

另外在多线程的情况下，这种实现方式是线程不安全的

 

实现三 线程安全的"懒汉模式"：解决线程问题，使用同步机制，两种实现方式，同步代码块和同步方法两种

（1）同步方法 （在方法上加synchronized修饰）

//懒汉式（线程安全的）
public class Singleton {

    //私有化构造器
    private Singleton(){}

    //内部实例化类的实例
    private static Singleton instance;
    

   //私有化对象，类通过公共方法调用(创建，返回实例)
   //方法上加同步锁
   public static synchronized Singleton getInstance(){
      if(instance==null) {
        instance=new Singleton();
      }
      return instance;
   }
}

（1）同步代码块 （在共享资源的代码外面，添加同步锁）

//懒汉式（线程安全的）
public class Singleton {

    //私有化构造器
    private Singleton(){}

    //内部实例化类的实例
    private static Singleton instance;

    public static  Singleton getInstance(){
        //对于一般的方法内，使用同步代码块，可以考虑使用this
        //对于静态的方法，使用当前类本身充当锁
        synchronized(Singleton.class){
            if(instance==null) {
                instance=new Singleton();
            }
        }
        return instance;
    }
}

 补充：同步方法和同步代码块,保证了线程安全，但是多线程的情况下，效率不高，需考虑最佳的实现方案

实现四 双重检查锁懒汉式：在同步代码块之前判断，单例是否实例化，如果没有实例化，那么第一个线程创建实例，之后的线程进入代码块之前，因为已经实例化，
所以不会执行同步代码块，既保证了线程安全，又提高了效率

//懒汉式（最佳）
public class Singleton {

    //私有化构造器
    private Singleton(){}

    //内部实例化类的实例
    private static Singleton instance;

    public static  Singleton getInstance(){

        //第一次检查instance是否被实例化，如果没有线程实例化，则进入if代码块
        if(instance==null) {
            //对于一般的方法内，使用同步代码块，可以考虑使用this
            //对于静态的方法，使用当前类本身充当锁
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }

        }
        return instance;
    }
}

上面的几种单例模式比较常见，补充一下其他的单例模式（静态内部类懒汉式和枚举单例）

静态内部类懒汉式

双重检查锁懒汉式由于使用了synchronized,锁机制，会带来一些性能问题
静态内部类懒汉式既可以解决饿汉式的内存浪费问题，也可以解决synchronized带来的性能问题

//静态内部类懒汉式
public class StaticLazyInnerClassSingleton {

    //私有构造方法
    private StaticLazyInnerClassSingleton(){}

    //公共方法调用,创建对象，并返回
    public static final StaticLazyInnerClassSingleton getInstance(){
        return InnerClass.instance;
    }

    private static class InnerClass{
        //final（保证不能够被修改）
        private static final StaticLazyInnerClassSingleton instance=new StaticLazyInnerClassSingleton();
    }
}

测试：

//静态内部类懒汉式
@Test
public  void testStaticInnerClassSingleton(){

    ExecutorService executorService= Executors.newCachedThreadPool();

    for (int i=0;i<10;i++){
    executorService.execute(new Runnable(){
        @Override
        public void run() {
           StaticLazyInnerClassSingleton instance=StaticLazyInnerClassSingleton.getInstance();
            System.out.println(Thread.currentThread().getName()+":"+instance);
        }
    });

    }
}

结果：

静态内部类懒汉式原理：
类的加载初始化顺序：
1.当类不被调用时，类的的静态内部类不会进行初始化，避免了内存的浪费
2.当调用 getInstance()方法时，会先初始化静态内部类，因为静态内部类中的成员变量是final,所以即便是多线程的情况下，其成员变量是不会被修改的，因此解决了添加sychronized带来的性能问题

枚举单例

//枚举单例
public enum  EnumSingleton {
    INSTANCE;
    private Object instance;
    EnumSingleton(){
        instance =new EnumResource();
    }
    public Object getInstance(){
        return  instance;
    }

}
class EnumResource{

}

测试：

//枚举单例
@Test
public void testEnumSingleton(){
    ExecutorService executorService= Executors.newCachedThreadPool();
    for (int i=0;i<10;i++){
        executorService.execute(new Runnable(){
            @Override
            public void run() {
                EnumSingleton instance=EnumSingleton.INSTANCE;
                System.out.println(Thread.currentThread().getName()+":"+instance.getInstance());
            }
        });

    }
}

结果：

 关于单例模式还有静态内部类懒汉式，以及枚举单例等 参考 https://www.cnblogs.com/eamonzzz/p/11633482.html

参考：https://www.cnblogs.com/binaway/p/8889184.html