单例模式

之前看过单例模式，昨天突然用到，就再回顾并总结了一下，当做复习。

  • 核心：保证一个类只有一个实例，并且提供一个访问该对象的全局访问点
  • 常见应用场景：
  1. Windows的任务管理器
  2. Windows的回收站
  3. 项目中，读取配置文件的类，一般也只有一个对象，没有必要酶促使用配置文件数据，每次new一个对象去读取
  4. ………
  • 优点：由于单例模式只生成一个实例， 减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。
  • 常见的五种单例模式的实现方式：
    •  主要：
      •  饿汉式：线程安全，调用效率高，但是不能延时加载
      • 懒汉式：线程不安全，调用效率不高，但是可以延时加载
    • 其他：
      • 双重检测锁式：由于JVM底层内部模型和Java平台内存模型原因，偶尔会出问题，不建议使用
      • 静态内部类式：线程安全，调用效率高，可以延时加载
      • 枚举单例：线程安全，调用效率高，不能延时加载
  • 代码实现：

    • 饿汉式：

    public class SingletonDemo01 {
         private SingletonDemo01(){}    //将构造器私有
         private static Singleton Demo01 instance=new SingletonDemo01();
         //类加载的时候就将对象new出来，不管后面用不用
         public static SingletonDemo01 getInstance(){    //提供一个对外开放的方法用来获取对象
               return instance;
         }
    }
  •  饿汉式总结：由于类加载时是线程安全的，方法不需要同步，因为对象在类加载的时候就new出来了，以后也不能改变，并且以后所有创建的对象都是这一个，都是同一个对象，所以没有延时加载的优势。

  • 懒汉式：

 
   public class SingletonDemo02 {
         private SingletonDemo02(){}    //将构造器私有
         private static SingletonDemo02 instance;
         //类加载的时候，不初始化这个对象(延时加载，真正用到的时候再创建)
         publicstatic synchronized SingletonDemo02 getInstance(){  //提供一个对外开放的方法用来获取对象
                //方法同步，调用效率低
           if(instance==null){ //如果为null，创建对象
                instance=new SingletonDemo02();
               }
               returninstance;
         }
    }
  • 懒汉式总结：懒汉式适合单线程，多线程情况下如果在创建对象实例对象时不加上synchronized，则会导致对对象的访问不是线程安全的。懒汉式是延时加载，在需要的时候才创建对象。资源利用率高了，但每次调用getInstance()方法都需要同步，并发效率低
 

  • 双重检测锁式：

public class SingletonDemo03 {
         private SingletonDemo03(){}    //将构造器私有
         private static SingletonDemo03 instance;
         //类加载的时候，不初始化这个对象(延时加载，真正用到的时候再创建)
         public static  SingletonDemo03 getInstance(){  //提供一个对外开放的方法用来获取对象
               //方法同步，调用效率低
               if(instance==null){ //Single Checked
                    synchronized(SingletonDemo03.class) {
                      if(instance==null){    //Double Checked
                           instance=new SingletonDemo03();
                          }
                    }
               }
           returninstance;
         }
    }
 
  • 双重检测锁式总结：将同步内容放在了if内部，提高了执行的效率，不必每次调用对象时都进行同步，只有第一次才同步，创建了以后就没有必要了。
 

  • 静态内部类实现：

 
public class SingletonDemo04 { 
         private static class singletonClassInstance{  //静态内部类
               privatestaticfinal SingletonDemo04 instance=newSingletonDemo04();
      }
         public static SingletonDemo04 getInstance(){
               return singletonClassInstance.instance; //通过静态内部类名来调用内部类中的成员
         }
         private SingletonDemo04(){}//构造器私有
    }
    • 静态内部类方式总结：外部类无static属性，不会像饿汉式那样立即加载对象，只有真正调用getInstance(),才会加载静态内部类，加载类时是线程安全的。instance是static

       final类型，保证了内存中只有这样一个实例存在，而且只被赋值一次，从而保证了线程安全性。兼并了高并发调用和延时加载的优势。而且调用效率高，并实现了延时加载。

  • 枚举方式：

public enum SingletonDemo05 {
         INSTANCE; //此元素本身就是单例对象
         //添加自己需要的操作
         public void singletonOperation(){    
         }
    }
  • 枚举方式总结：
    • 优点：实现简单，枚举本身就是单例模式，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞。
    • 缺点：无延时加载。
   初学菜鸟，大神请略过。

版权声明：本文为zhangnianxiang原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zhangnianxiang/p/8821207.html