一、介绍

• 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。
• 应用场景在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

二、单例模式的种类

2.1、饿汉式：

• 饿汉式实现的手法有两种：（1）静态常量，（2）静态代码块；
• 在类加载时已经创建好该单例对象，等待被程序使用

2.1.1、代码实现

• 静态常量

public class Hungry {/*** 饿汉模式一：静态常量*/public static final Hungry hungry = new Hungry();//必须要将构造器用private进行修饰private Hungry() {}//通过该方法获取hungryprivate static Hungry getInstance() {return hungry;}
}

• 静态代码块

public class Hungry {/*** 饿汉模式二：静态代码块*/public static final Hungry hungry2;//在静态代码块里初始化static {hungry2 = new Hungry();}//必须要将构造器用private进行修饰private Hungry() {}//通过该方法获取hungryprivate static Hungry getInstance2() {return hungry2;}
}

2.1.2、注意事项

• 这种方式只适合在单线程中使用；
• 这种方式可能存在内存浪费；

2.2、懒汉式

• 在真正需要使用对象时才去创建该单例类对象；
• 懒汉式一共有三种方式，每种方式各有弊端。

2.2.1、代码实现

• 方式一：通过判断single是否被初始化，从而进行对象的实例化。如果该对象还未被实例化，则会进行实例化。如果已经实例化，则不会再实例化。
• 但是，这种方式存在线程安全问题。假设有一个线程刚刚将if (null == single)条件实行完，时间片就完了。然后另一个线程又来获取该对象，此时，single还未被初始化，所以第二次进来的线程会进行new过程。当第一次的那个线程再次获取到时间片后，会从上一次运行的地方接着运行，所以会再次执行new操作。所以，一个实例被new了两次，这就不符合单例模式的定义了。
• 优缺点说明：
• 该模式起到了Lazy Loading的效果，但是只能在单线程下使用。
• 如果在多线程下，一个线程进入了if(single == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以，在多线程环境下不可使用这种方式。
• 结论：在实际开发中，不要使用这种方式。

public class Single {private static Single single;private Single() {}//懒汉模式一：存在线程安全问题private static Single getInstance() {if (null == single) {single = new Single();}return single;}
}

• 方式二：通过给方法加上锁，从而避免了多个线程同时进入该方法中去。因此不会造成单线程安全问题。
• 但是，单例模式只需要new一次，所以，如果这样写，在每次调用该方法时都要进行锁的获取，如果该方法被其他线程占用着，则下一个线程到来后不能及时运行该方法。从而降低效率。
• 优缺点说明：
• 解决了线程不安全问题。
• 效率太低了，每个线程在想获得实例的时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就行了。后面想获得该实例，直接return就行。方法同步效率太低了。
• 结论：在实际开发中，不推荐使用这种方式。

public class Single {private static Single single;private Single() {}//懒汉模式二：不存在线程安全模问题。//但是每次get都要进行同步，效率太低。毕竟单例只要new一次。private static synchronized Single getInstance2() {if (null == single) {single = new Single();}return single;}
}

• 方式三：因为方式二解决了多线程安全问题，所以就有人提出，可以通过改变锁的位置，从而解决方式二的效率低下的问题。更改方式如下面代码所示；
• 但是，通过更改代码，虽然解决了效率低下的问题，但是又将线程不安全问题给再次引入。理解方式，和方式二同理。
• 优缺点说明：
• 这种方式本意是对上一个方式的改进，因为上一个方式的效率太低。
• 但是这种同步并不能起到线程同步的作用。
• 结论：在实际开发中，不能使用这种方式。

public class Single {private static Single single;private Single() {}//懒汉模式三：解决了效率问题，但是有存在线程安全问题private static Single getInstance3() {if (null == single) {synchronized (Single.class) {single = new Single();}}return single;}
}

2.3、双重检测模式

• 这种模式是将上面懒汉模式进行的改良后的产物。经过·上面的分析，相信大家对懒汉模式的优缺点都已经很清楚了。但是上面的懒汉模式都不适合在实际开发中去使用。为了在实际开发中更好的使用，因此对上面的懒汉模式进行再次的改良。

2.3.1、代码实现

• 通过上面分析可以得出，加锁可以解决线程安全问题，但是如何合理的将锁应用到这个里面，从而使得该方法即可以解决多线程安全问题，还可以解决效率过低的问题。
• 解决方案：首先通过if条件判断，从而得知成员doubleCheck是否被实例化。如果一个线程刚刚完成第一个条件判断时间片就用完了，当第二个线程完成实例化后，第一个线程再次获取到锁后，因为doubleCheck被volatile修饰，所以在第二个线程完成实例化后，当第一个线程再次获取到时间片后，就会检测到该成员已经实例化就不会再次实例，从而解决了多线程问题，同时当有其他线程再次运行该方法时，由于该成员已经被实例化了，从而就不会再次实例化，会直接返回已经实例化好的成员。从而也解决了效率太低的问题。

/*** 双重检测模式*/
public class DoubleCheck {//注意，要加上volatile关键字private volatile static DoubleCheck doubleCheck;private DoubleCheck() {}/*** 可以解决线程安全问题和效率问题；*/private static DoubleCheck getInstance() {if (null == doubleCheck) {synchronized (DoubleCheck.class) {if (null == doubleCheck) {doubleCheck = new DoubleCheck();}}}return doubleCheck;}
}

2.4、静态代码块模式

• 这种方式采用了类加载的机制来保证初始化实例时只有一个线程。
• 静态内部类方式在StaticClass类被加载时并不会立即实例化，而是在需要实例化时，调用getInterface方法，才会装载SingleInstancce类，从而完成StaticClass实例化。
• 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性。在类初始化时，别的线程是无法进入的。
• 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
• 结论：推荐使用。

2.4.1、代码实现

/*** 通过静态内部类获取** 优点：不会存在线程安全问题，不会存在内存浪费问题；*/
public class StaticClass {private StaticClass() {}/*** 静态内部类*/private static class StaticInstance {private static final StaticClass INSTANCE = new StaticClass();}/*** 获取对象*/private static StaticClass getInstance() {return StaticInstance.INSTANCE;}
}

2.5、枚举模式

• 这借助JDK1.5添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重现创建创建新的对象。
• 这种方式是Effectiive Java作者Josh Bloch提倡的方式。
• 结论：推荐使用

2.5.1、代码实现

public enum EnumWay {INSTANCE;public void method() {System.out.println("OK");}
}