Java创建者模式（一）——单例设计模式（饿汉式、懒汉式、枚举式 | 完成详解，附有代码+案例）

单例设计模式

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

4.1.1 单例模式的结构

单例模式的主要有以下角色：

• 单例类。只能创建一个实例的类，即只能创建一个对象。
• 访问类(也就是测试类),使用单列类

4.1.2 单例模式的实现

单例设计模式分类两种：​	饿汉式：类加载就会导致该单实例对象被创建	​	懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

4.1.2.1 饿汉式-静态变量方式

饿汉式,方式1----静态变量方式

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

//饿汉式,方式1----静态变量方式
public class SingLeton {// 1.私有构造方法，让外界不能创建该类的对象。private SingLeton() {}// 2.在本类中的成员位置创建本类的对象// 此处的static是根据3.中的方法是静态方法设置的private static SingLeton instance = new SingLeton();// 3.提供一个公共的访问方式，让外界获取该对象，所以用staticpublic static SingLeton getInstance(){return instance ;}
}
===========================================================public class Test {public static void main(String[] args) {// 创建SingLeton类的对象SingLeton instance1 = SingLeton.getInstance();SingLeton instance2 = SingLeton.getInstance();// 判断获取的是否是同一个对象boolean b = instance1 == instance2;System.out.println(b);//true,说明创建了一个对象}
}

4.1.2.2 饿汉式-静态代码块方式

饿汉式，方式1----静态代码块方式

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

//饿汉式----静态代码块方式
public class SingLeton {// 1.私有构造方法,不让外界创捷该类的对象private SingLeton() {}// 2.声明SingLeton类型的变量private static SingLeton instace;//null// 3.静态代码块中进行赋值static {instace = new SingLeton();}// 4.对外提供获取该类对象的方法public static SingLeton getInstance(){return instace;}
}
=========================================================public class Test {public static void main(String[] args) {// 创建SingLeton类的对象SingLeton instance1 = SingLeton.getInstance();SingLeton instance2 = SingLeton.getInstance();// 判断获取的是否是同一个对象boolean b = instance1 == instance2;System.out.println(b);//true,说明创建了一个对象}
}

4.1.2.3 懒汉式-线程不安全

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

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

//懒汉式----方式1
public class Singleton {// 1.私有构造方法,不让外界创捷该类的对象private Singleton() {}// 2.声明Singleton类型的变量//只是声明没有赋值private static Singleton instance;// 3.对外提供访问方式public static Singleton getInstance() {//判断instace是否是null,//如果为null,说明还没有Singleton类的对象//如果没有，创建并返回；如果有，直接返回//如果没有if循环判断测试类的结果为false,// 因为每调用getInstance()方法就会创建新的Singleton对象//也违背单一规则if (instance == null){//假设两个线程，当线程1走到此行，cpu执行权被线程2抢走，//则线程2也会到判断里面，此时再执行会创建两个对象，//违背单一规则。instance = new Singleton();}return instance;}
}
=========================================================public class Test {public static void main(String[] args) {Singleton instance1 = Singleton.getInstance();Singleton instance2 = Singleton.getInstance();boolean b = instance1 == instance2;System.out.println(b);//ture}
}

4.1.2.4 懒汉式-线程安全

懒汉式----方式2–线程安全

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

//懒汉式----方式2--线程安全
public class Singleton {// 1.私有构造方法,不让外界创捷该类的对象private Singleton() {}// 2.声明Singleton类型的变量//只是声明没有赋值private static Singleton instance;// 3.对外提供访问方式public static synchronized Singleton getInstance() {if (instance == null){//此处将创建的对象赋值给instance，为写操作//假设有两个线程，当线程1走到此行，cpu执行权被线程2抢走，//由于加锁，线程2进不来，只有当线程1执行结束，线程2可能进来//如果没锁，线程2也会到判断里面，此时再执行会创建两个对象，instance = new Singleton();}//如果instancey已经创建，则直接返回，返回的这个操作为读操作return instance;}
}
============================================public class Test {public static void main(String[] args) {// 创建SingLeton类的对象Singleton instance1 = Singleton.getInstance();Singleton instance2 = Singleton.getInstance();// 判断获取的是否是同一个对象boolean b = instance1 == instance2;System.out.println(b);//ture}
}

4.1.2.5 懒汉式-双重检查锁

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

懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式.

// 懒汉式-方式3（双重检查锁）
public class Singleton {//1. 声明Singleton类型的变量private static Singleton instance ;//2.私有构造方法private Singleton (){};//3.对外提供静态的getXxxx方法获取该对象public static Singleton getInstance(){//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例if (instance == null){synchronized (Singleton.class){//抢到锁之后再次判断是否为nullif (instance == null){instance = new Singleton();}}}return instance;}}
=========================================================public class Test {public static void main(String[] args) {// 创建SingLeton类的对象Singleton instance1 = Singleton.getInstance();Singleton instance2 = Singleton.getInstance();// 判断获取的是否是同一个对象boolean b = instance1 == instance2;System.out.println(b);//true}
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

// 懒汉式-方式3（双重检查锁），使用 volatile 关键字, 
public class Singleton {//1. 声明Singleton类型的变量,添加volatile关键字private static volatile Singleton instance ;//2.私有构造方法private Singleton (){};//3.对外提供静态的getXxxx方法获取该对象public static Singleton getInstance(){//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例if (instance == null){synchronized (Singleton.class){//抢到锁之后再次判断是否为nullif (instance == null){instance = new Singleton();}}}return instance;}}
=========================================================public class Test {public static void main(String[] args) {// 创建SingLeton类的对象Singleton instance1 = Singleton.getInstance();Singleton instance2 = Singleton.getInstance();// 判断获取的是否是同一个对象boolean b = instance1 == instance2;System.out.println(b);//true}
}

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

4.1.2.6 枚举式

待更新…