JAVA设计模式之单例模式

单例模式是一种常见的设计模式，本文介绍七种单例模式。

单例模式的特点：

• 单例模式只能有一个实例
• 单例类必须自己创建自己唯一实例
• 单例类必须给所有其他对象提供这一实例

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

单例模式的特点：构造函数私有，公有函数返回实例对象。

1、饿汉单例

饿汉单例模式是线程安全的，安全是由类的加载机制保证的。在类创建的时候就已经创建好一个静态的对象供系统使用，以后不再改变。

   //饿汉单例模式（快加载）
public class Single{
    private static final Singleton people=new Singleton();
    private Singleton(){
    }
    public static Singleton getInstance(){
        return people;
    }
}

2、懒汉单例模式

懒汉单例模式和饿汉单例模式的区别就是：懒汉创建了延迟对象，同时饿汉式的单例对象是被修饰为final类型。

优点：尽最大可能节省内存空间

缺点：在多线程编程中，使用懒汉式可能造成类的对象在内存中不唯一。是线程不安全的。

public class single{
//懒汉单例模式(慢加载)
    private static Singleton people;
    private Singleton(){

    }
    public static Singleton getInstance(){
        if (people==null){
            Singleton people=new Singleton();
        }
        return people;
    }
}

3、全局锁式

是线程安全的，线程同步时效率不高（synchronized）

public class Singleton{

     private static Singleton singleton;
     private Singleton(){}
     //synchronized修饰的是静态方法，锁 类对象
     public synchronized static Singleton getInstance(){
         if (singleton==null){
             singleton=new Singleton();
         }
         return singleton;
         
     }
}

4、静态代码块

是线程安全的，类主动加载时才初始化实例，实现了懒加载策略，且线程安全

public class Singleton{
     //静态代码块
    private final static Singleton singleton;
    private Singleton{}
    static {
        singleton = new Singleton();
    }
    public static Singleton getInstance(){

        return singleton;

    }

    public static void main(String[] args) {
        //第一次调用Singleton,JVM需要负责将Singleton加载到内存中，在加载的过程处理静态代码块
        Singleton.getInstance();
        //第二次调用Singleton,JVM中已经存在Singleton，直接使用getInstance
        Singleton.getInstance();
    }

}

5、双重校验锁式

是线程安全的，且实现了懒加载策略，同时保证了线程同步时的效率。但是volatile强制当前线程每次读操作进行时，保证其他所有线程写操作已完成。volatile使得JVM内部的编译器舍弃了编译时优化，对于性能有一定的影响。

public class Singleton{
    private static volatile Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        if (singleton == null){
            synchronized (Singleton.class){
                if (singleton==null){
                    //内层if判断使用的时间（起作用时机）
                    //第一次两线程同时调用getInstance，都会进入外层if判断
                    //内层if判断是针对第二个进入synchronized代码块线程，此时第一个线程已经创建出对象
                    //第二个线程无需创建
                    singleton =new Singleton();
                }
            }
        }
     return singleton;
    }



}

6、静态内部类式（推荐）

是线程安全的，不存在线程同步问题，且单例对象在程序第一次getInstance()时主动加载SingletonHolder和静态成员INSTANCE

public class Singleton{
   //静态内部类式（推荐）
     private Singleton(){}
     private static class SingletonHolder{
         private static final Singleton INSTANCE =new Singleton();
     }
     public static Singleton getInstance(){
         return SingletonHolder.INSTANCE;
     }
}

7、枚举式

线程安全，不存在线程同步问题，且单例对象在枚举类型INSTANCE，第一次引用时通过枚举的构造函数初始化。它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

public class Singleton{
   private Singleton(){}
    enum SingletonEnum{
        INSTANCE;
        private final Singleton singleton;
        private SingletonEnum(){
            singleton =new Singleton();
        }
    }
    public static Singleton getInstance(){
        return SingletonEnum.INSTANCE.singleton;
    }
   
}