单例模式介绍与java的几种实现方式

介绍

单例模式属于创建型模式，这种模式涉及到一个单一的类。

• 单例类只能有一个实例
• 单例类必须自己创建这个实例 -> 构造函数私有化
• 单例类必须给其他所有对象提供这一实例 -> public

场景： 当一个全局使用的类频繁地创建与销毁，想要控制实例数目，节省系统资源
解决： 保证一个类只有一个实例，，并提供一个访问它的全局访问点。当有个单例对象时直接返回，没有时先创建再返回
关键代码： 构造函数私有化
应用：

• 一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件
• Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行

Java实现

   public static void main(String[] args) {
 
      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //Singlenton object = new Singlenton();
 
      //获取唯一可用的对象
      Singlenton object = Singlenton.getInstance();
   }

1.懒汉式

1.1懒汉式，线程不安全

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作

/***
 *必须把构造函数设置为私有函数，以禁止他人创建实例
 * 只有instance为null时才创建实例
 */
public class Singleton1{
    //本部内部创建实例对象
    private static Singleton1 instance = null;
    
    private Singleton1(){
    }
    //提供一个公有的静态方法，返回实例对象
    public static  Singleton1 getInstance(){
        if(instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

1.2懒汉式，线程安全

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
第一次调用才初始化，避免内存浪费，但必须加锁synchronized才能保证单例，但加锁影响效率

public class Singleton2{
    //本部内部创建实例对象
    private static Singleton2 instance = null;
    
    private Singleton1(){
    }
    //提供一个公有的静态方法，返回实例对象
    public static  synchronized Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

2.饿汉式

非lazy，多线程安全
比较常用，但容易产生垃圾文件
基于classloader机制避免了多线程同步的问题

public class Singleton3{
    private static Singleton3 instance = new Singleton3();
    private Singleton3(){
        
    }
    public static Singleton3 getInstance(){
        return instance;
    }
}

3.双检锁/双重检验锁

lazy初始化，多线程安全

public class Singleton4{
    private volatile static Singleton4 instance;
    private Singleton4(){}
    public static Singleton4 getInstance(){
    	//对类加锁
        synchronized (Singleton4.class){
            if(instance == null){
                instance = new Singleton4();
            }
        }
        return instance;
    }
}

4.登记式/静态内部类

lazy初始化，多线程安全。
利用内部类，当主动使用内部类时才会实例化instance，

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

public class Singleton5{
    private static class Singleton5Handler{
        private static final Singleton5 instace = new Singleton5();
    }
    private Singleton5(){};
    public static Singleton5 getInstance(){
        return Singleton5Handler.instace;
    }
}

5.枚举（最佳方案）

lazy初始化，多线程安全

public enum Singleton6{
    instance;
    public void whateverMethod(){
        
    }
}

6.总结

一般不使用1.1和1.2，可以使用2。只有在要明确实现 lazy loading 效果时，才会使用第 4 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 5 种枚举方式。如果有其他特殊的需求，可以考虑使用第 3 种双检锁方式。