定义：

确保一个类最多只有一个实例，并提供一个全局访问点。
单例模式可以分为两种：预加载和懒加载。

优缺点

优点

  • 由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能；

    缺点

  • 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难；

  • 不适用于经常变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态；

    单例模式的使用场景

    单例模式只允许创建一个对象，因此节省内存，加快对象访问速度。适合在对象需要被公用的场合使用，如多个模块使用同一个数据源连接对象等等。
    1、需要频繁实例化然后销毁的对象；
    2、创建对象时耗时过多或者耗资源过多，但又经常用到的对象；
    3、有状态的工具类对象；
    4、频繁访问数据库或文件的对象；

    应用场景举例：

    （1）外部资源：每台计算机有若干个打印机，但只能有一个PrinterSpooler，以避免两个打印作业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件
    （2）Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧）。你能打开两个windows task manager吗？ 不信你自己试试看哦~
    （3）windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
    （4）网站的计数器，一般也是采用单例模式实现，否则难以同步。
    （5）应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
    （6） Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
    （7）数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
    （8）多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
    （9）操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
    （10）HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例。

    单例模式的实现方法

    1.饿汉式单例

    很明显，没有使用该单例对象，该对象就被加载到了内存，会造成一定的内存浪费。

    1. //饿汉式单例
    2. public class Hungry {
    3.   //可能会很费空间
    4.   private byte[] data1 = new byte[1024*1024];
    5.   private byte[] data2 = new byte[1024*1024];
    6.   private byte[] data3 = new byte[1024*1024];
    7.   private byte[] data4 = new byte[1024*1024];
    9.   private Hungry(){
    11.   }
    12.   private final static Hungry HUNGRY= new Hungry();
    14.   public static Hungry getInstance(){
    15.       return HUNGRY;
    16.   }
    17. }

    2.懒汉式单例

    存在多线程并发模式，线程不安全。后面的DCL懒汉式解决并发问题！ ```java public class LazyMan { private LazyMan(){

    1.   System.out.println(Thread.currentThread().getName()+"OK");

    }

    private static LazyMan lazyMan;

  1. //双重检测锁模式的  懒汉式单例    DCL懒汉式
  2. public static LazyMan getInstance(){
  3.     if(lazyMan==null){
  4.         lazyMan = new LazyMan();//不是一个原子性操作
  5.     }
  6.     return lazyMan;
  7. }
  8. /*
  9. * 1.分配内存空间
  10. * 2、执行构造方法，初始化对象
  11. * 3、把这个对象指向者个空间
  12. *
  13. * 123
  14. * 132 A
  15. *
  16. *     B //此时lazyMan还没有完成构造
  17. *
  18. * */
  21. //多线程并发
  22. public static void main(String[] args) {
  23.     for (int i = 0; i < 10; i++) {
  24.         new Thread(()->{
  25.             LazyMan.getInstance();
  26.         }).start();
  27.     }
  28. }

}

  1. <a name="QDx3G"></a>
  2. ### 3.DCL懒汉式
  3. 注意：**synchronized** 解决并发问题。但是因为lazyMan = new LazyMan();不是原子性操作(可以分割，见代码注释)，可能发生指令重排序的问题，通过**volatile**来解决！
  5. - Java 语言提供了 volatile和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。
  6. - 原子性就是指该操作是不可再分的。不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作。简而言之，在整个操作过程中不会被线程调度器中断的操作，都可认为是原子性。比如 a = 1；
  7. ```java
  8. import java.lang.reflect.Constructor;
  9. import java.lang.reflect.Field;
  11. //懒汉式单例
  13. public class LazyMan {
  14.     private static boolean qingjiang = false;//红绿灯解决通过反射创建对象（反编译可以破解该方法）
  15.     private LazyMan(){
  16.         synchronized (LazyMan.class){
  17.             if (qingjiang==false){
  18.                 qingjiang = true;
  19.             }else{
  20.                 throw new RuntimeException("不要试图使用反射破坏单例");
  21.             }
  23.         }
  24.         System.out.println(Thread.currentThread().getName()+"OK");
  25.     }
  27.     private volatile static LazyMan lazyMan;//volatile避免指令重排
  30.     //双重检测锁模式的  懒汉式单例    DCL懒汉式
  31.     public static LazyMan getInstance(){
  32.         if(lazyMan==null){
  33.             lazyMan = new LazyMan();//不是一个原子性操作
  34.         }
  35.         return lazyMan;
  36.     }
  38. //加了synchronized双重检查锁以及volatile解决指令重排后线程安全了，但可以被反射破坏！
  39. public static void main(String[] args) throws Exception {
  40.     //LazyMan instance = LazyMan.getInstance();
  41.     Field qingjiang = LazyMan.class.getDeclaredField("qingjiang");
  42.     qingjiang.setAccessible(true);
  44.     Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
  45.     declaredConstructor.setAccessible(true);//无视私有的构造器
  46.     LazyMan instance1 = declaredConstructor.newInstance();
  47.     qingjiang.set(instance1,false);
  48.     System.out.println(instance1);
  49.     LazyMan instance2 = declaredConstructor.newInstance();
  51.     System.out.println(instance2);
  53. }
  55.     /*
  56.     * 1.分配内存空间
  57.     * 2、执行构造方法，初始化对象
  58.     * 3、把这个对象指向者个空间
  59.     *
  60.     * 123
  61.     * 132 A
  62.     *
  63.     *     B //此时lazyMan还没有完成构造
  64.     *
  65.     * */
  68.     //多线程并发
  69.    /* public static void main(String[] args) {
  70.         for (int i = 0; i < 10; i++) {
  71.             new Thread(()->{
  72.                 LazyMan.getInstance();
  73.             }).start();
  74.         }
  75.     }*/
  76. }
  78. -----------————————————————————————————————————————————————————————————————————————————————————————————————————-----------
  79. //反射不能破坏枚举！
  80. import java.lang.reflect.Constructor;
  82. //enmu是什么？本身也是一个class类
  83. public enum EnumSingle {
  84.     INSTANCE;
  85.     public EnumSingle getInstance(){
  86.         return INSTANCE;
  87.     }
  88. }
  90. class Test{
  91.     public static void main(String[] args) throws Exception {
  92.         EnumSingle instance = EnumSingle.INSTANCE;
  93.         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
  94.         declaredConstructor.setAccessible(true);
  95.         EnumSingle instance2 = declaredConstructor.newInstance();
  97.         //java.lang.NoSuchMethodException: com.ph.single.EnumSingle.<init>()
  98.         System.out.println(instance);
  99.         System.out.println(instance2);
  101.     }
  102. }

枚举: 通过反射破解枚举发现不成功：

  1. 普通的反编译会欺骗开发者，说enum枚举是无参构造 ；
  2. 实际enum为有参构造（见后面）；
  3. 通过反射破解枚举会发现抛出异常

    4.总结

  1. 当一个类的对象只需要或者只可能有一个时，应该考虑单例模式。
  2. 如果一个类的实例应该在JVM初始化时被创建出来，应该考虑使用饿汉式。
  3. 如果一个类的实例不需要预先被创建，也许这个类的实例并不一定能用得上，也许这个类的实例创建过程比较耗费时间，也许就是真的没必要提前创建。那么应该考虑懒汉式。
  4. 在使用懒汉式单例的时候，应该考虑到线程的安全性