单例设计模式精讲（饿汉式和懒汉式实现的重要方法）

什么叫做单例模式？

饿汉式和懒汉式的区别？

饿汉式-方式1（静态变量方式）

饿汉式-方式2（静态代码块方式）

懒汉式-方式1（线程不安全）

懒汉式-方式2（线程安全）

懒汉式-方式3（双重检查锁）

懒汉式-方式4（静态内部类方式）

什么叫做单例模式？

涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

饿汉式和懒汉式的区别？

饿汉式：类加载就会导致该单实例对象被创建
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
导致类加载的情况：new 对象，创建子类，调用静态属性
类加载是什么意思：就是把你的变量和方法存在内存当中
代码区别如下：
人话来说就是创建对象的时机不一样，如果看不懂的话建议去补java基础静态这一块的知识

//饿汉式
public class Singleton {private Singleton(){}
//    提前创建好单列对象；private static Singleton instance = new Singleton();public static Singleton getInstance(){return instance;}}
//测试代码：
public class Test {public static void main (String[] args) {//因为这里调用的是静态方法，所以导致类加载，就会执行 new Singleton();从而创建对象//导致类加载的情况：new 对象，创建子类，调用静态属性Singleton instance = Singleton.getInstance();Singleton instance1 = Singleton.getInstance();System.out.println(instance==instance1);}
}
============================================================================
//饿汉式
public class Singleton {private Singleton(){}private static Singleton instance;public static Singleton getInstance(){if (instance==null){//调用的时候才创建对象//判短对象为空才创建对象instance=new Singleton();}return instance;}
}
public class Test {public static void main (String[] args) {//调用方法的时候才创建对象Singleton instance = Singleton.getInstance();Singleton instance1 = Singleton.getInstance();System.out.println(instance==instance1);}
}

饿汉式-方式1（静态变量方式）

/**
* 饿汉式
* 静态变量创建类的对象
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance = new Singleton();
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return instance;
}
}

缺点：
该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。 instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

饿汉式-方式2（静态代码块方式）

/**
* 恶汉式
* 在静态代码块中创建该类对象
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
static {
instance = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return instance;
}
}

缺点：
该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式-方式1（线程不安全）

/**
* 懒汉式
* 线程不安全
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

缺点：
从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

懒汉式-方式2（线程安全）

/**
* 懒汉式
* 线程安全
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

缺点：
该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了 synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

就是每个现场都会拿到锁，导致效率降低，应该是当没有获取对象的谁时候拿到锁。

懒汉式-方式3（双重检查锁）

public class Singleton {private Singleton(){}//声明一个Singleton类型的变量private static Singleton instance;public static Singleton getInstance(){if (instance==null){//为空的时候才会拿到锁synchronized (Singleton.class){if (instance==null){instance=new Singleton();}}}return instance;}
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

懒汉式-方式4（静态内部类方式）

public class Singleton {
//私有构造方法
private Singleton() {}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder 并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。小结：静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。