设计模式之单列模式

单列模式：采用一定的方法保证整个软件系统中，对某个类只能存在一个实列，并且该实列只提供一个取到该对象实例的方法，该方法为静态方法。

单列模式常见的几种写法以及其优缺点：

1、饿汉式（静态常量）

public class SingletonTest1 {     public static void main(String[] args) {         SingleTonDemo1 instance = SingleTonDemo1.getInstance();         SingleTonDemo1 instance1 = SingleTonDemo1.getInstance();         System.out.println(instance == instance1);     } } /**  * 单列模式（饿汉式） 静态常量  * @author Administrator  *  */ class SingleTonDemo1{     /**定义私有的构造方法,让外部不能通过new来获取实列对象**/     private SingleTonDemo1() {     }      //定义一个静态的实列对象     private final static SingleTonDemo1 instance = new SingleTonDemo1();     //定义一个获取实列对象的方法     public static SingleTonDemo1 getInstance() {         return instance;     } }

2、饿汉式（静态代码块）

public class SingletonTest2 {     public static void main(String[] args) {         SingletonDemo2 instance =SingletonDemo2.getInstance();         SingletonDemo2 instance1 =SingletonDemo2.getInstance();         System.out.println(instance == instance1);     } } class SingletonDemo2{     private SingletonDemo2() {}     private static SingletonDemo2 instance;     static {         instance = new SingletonDemo2();     }     public static SingletonDemo2 getInstance() {         return instance;     } }

1和2两种写法类似，优点是写法简单，在类装载的时候进行了实列化，避免了线程同步问题。缺点是在类装载的时候进行实列化，没有达到懒加载的效果，如果该对象实例一直没有使用会造成内存浪费。

3、懒汉式，优点是达到懒加载的效果，缺点是线程不安全，在多线程的情况下会实列化出多个线程，没有达到单列模式的效果。

public class SingletonTest3 {     public static void main(String[] args) {         System.out.println("多线程模式下测试该方法：");         for (int i = 0; i < 10; i++) {             new Thread(() -> {                 SingletonDemo3 instance = SingletonDemo3.getInstance();                 System.out.println("获取实列对象的hashCode:" + instance.hashCode());             },String.valueOf(i)).start();         }     } } class SingletonDemo3 {          private SingletonDemo3() {}          private static SingletonDemo3 instance;          public static SingletonDemo3 getInstance() {         if(instance == null) {             instance = new SingletonDemo3();         }         return instance;     } }

4、懒汉式（线程安全，同步方法）   优点是解决了线程安全问题，达到了懒加载的效果，缺点是效率低，使用synchronized关键字效率低。

public class SingletonTest4 {     public static void main(String[] args) {         System.out.println("多线程模式下测试该方法：");         for (int i = 0; i < 10; i++) {             new Thread(() -> {                 SingletonDemo4 instance1 = SingletonDemo4.getInstance();                 System.out.println("获取实列对象的hashCode:" + instance1.hashCode());             },String.valueOf(i)).start();         }              } } class SingletonDemo4{          private SingletonDemo4() {};          private static SingletonDemo4 instance;          public static synchronized SingletonDemo4 getInstance() {         if(instance == null) {             instance = new SingletonDemo4();         }         return instance;     } }

5、双重检查的方法，线程安全，延迟加载，效率较高，在系统中推荐使用。

public class SingletonTest5 {     public static void main(String[] args) {         //测试多线程环境下的结果         for (int i = 0; i < 10; i++) {             new Thread(() -> {                 SingleDemo5 instance = SingleDemo5.getInstance();                 System.out.println(instance.hashCode());             },String.valueOf(i)).start();;         }     } } class SingleDemo5{     private static SingleDemo5 instance;          private SingleDemo5() {};          public static SingleDemo5 getInstance() {         if(instance == null) {             synchronized (SingleDemo5.class) {                 if(instance == null) {                     instance = new SingleDemo5();                 }             }         }         return instance;     }      }

6、静态内部类，采用类转载的机制来保证初始化实列只有一个线程，静态内部类在外部类装载的时候并不会马上被实例化，在外部类调用它的时候才开始实例化，而内部类是静态属性，只会在第一次加载的时候进行初始化，来保证初始化的安全性。这样效率高，推荐使用。

public class SingletonTest6 {     public static void main(String[] args) {         for (int i = 0; i < 10; i++) {             new Thread(() ->  {                 System.out.println(SingleDemo6.getInstance().hashCode());             },String.valueOf(i)).start();         }     } } class SingleDemo6{          private SingleDemo6() {};          /**静态内部类**/     private static class SingletonHolder{         private static final SingleDemo6 INSTANCE = new SingleDemo6();     }          public static SingleDemo6 getInstance() {         return SingletonHolder.INSTANCE;     } }

7、采用枚举的方式来实现，这种方式推荐使用。

public class SingleTest7 {     public static void main(String[] args) {         for (int i = 0; i < 10; i++) {             new Thread(() ->  {                 System.out.println(SingleDemo7.INSTANCE.hashCode());             },String.valueOf(i)).start();         }     } } enum SingleDemo7{          INSTANCE; }

使用注意事项和细节：

1. 单列模式保证系统内存中该类只存在一个对象实例，节省系统资源，对于需要频繁创建和销毁的对象使用单列模式可以提供系统的性能。
2. 需要获取到单列对象的时候千万不能通过new关键字，要通过内部提供的方法来获取对象信息。
3.