单例模式

单例模式主要有两种表现形式

一、饿汉式单例模式

线程不安全

public class Singleton {

    private static Singleton m_instance = new Singleton();

    private Singleton(){
        System.out.println("生成了一个实例");
    }

    public static Singleton  getInstace(){
        return m_instance;
    }

}

在类被加载时，静态变量m_instance会被初始化（类只会被加载一次，即初始化一次）。此时类的私有构造函数会被调用，单例类的唯一实例被创建出来。单例类中最重要的是构造函数私有，避免外界利用构造函数直接创建任意数量实例。需要注意的是，由于构造函数是私有的，因此该类不能被继承。

测试类：

public class Main {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstace();
        Singleton instance2 = Singleton.getInstace();
        System.out.println(instance1);
        System.out.println(instance2);
        System.out.println(instance1==instance2);
    }
}

结果：

二、懒汉式单例模式

线程不安全

/**
 * 懒汉式
 */
public class Singleton2 {
    private static Singleton2 m_instance;
    private Singleton2(){
        System.out.println("产生一个实例");
    }
    public static Singleton2 getInstance(){
        if (m_instance==null){
            m_instance = new Singleton2();
        }
        return m_instance;
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        Singleton2 instance3 = Singleton2.getInstance();
        Singleton2 instance4 = Singleton2.getInstance();
        System.out.println(instance3);
        System.out.println(instance4);
        System.out.println(instance3==instance4);
    }
}

结果：

懒汉式和饿汉式相同的是，构造函数都是私有
不同的是懒汉式在加载时不会将自己实例化，而是在第一次被调用时将自己实例化

三、双检锁

线程安全

public class Singleton3 {
    private static volatile Singleton3 m_instance;
    private Singleton3(){
    }
    public static Singleton3 getInstance(){
        if (m_instance == null){
            synchronized (Singleton3.class){
                if (m_instance==null){
                    m_instance = new Singleton3();
                }
            }
        }
        return m_instance;
    }
}

只有在对象需要被使用时才创建，第一次判断 m_instance == null为了避免非必要加锁，当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。但是，由于jvm存在乱序执行功能，双重锁也会出现线程不安全的情况。

m_instance = new Singleton3()
这个步骤，其实在jvm里面的执行分为三步：
1.在堆内存开辟内存空间。
2.在堆内存中实例化SingleTon里面的各个参数。
3.把对象指向堆内存空间。

由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了3，INSTANCE 已经非空了，会被直接拿出来用，这样的话，就会出现异常。

volatile确保m_instance 每次均在主内存中读取，解决线程安全问题

四、静态内部类

线程安全

public class Singleton4 {
    private Singleton4(){

    }
    private static class SingletonHolder{
        private static final Singleton4 m_instance = new Singleton4();
    }

    public static final Singleton4 getInstance(){
        return SingletonHolder.m_instance;
    }
}

外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化m_instance ，故而不占内存。即当SingleTon4第一次被加载时，并不需要去加载SingletonHolder，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingletonHolder类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。如果执行<clinit>()方法后，其他线程唤醒之后不会再次进入<clinit>()方法。同一个加载器下，一个类型只会初始化一次，所以保证了线程安全。

五、枚举

线程安全

public enum SingleTon{
  INSTANCE;
        public void method(){
        //TODO
     }