设计模式之单例模式

单例模式

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

• 核心：保证一个类只有一个实例，并且提供一个访问该对象的全局访问点
• 常见应用场景：

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 ;

            //类加载的时候，不初始化这个对象(延时加载，真正用到的时候再创建)

            public static   synchronized SingletonDemo02 getInstance(){   //提供一个对外开放的方法用来获取对象

                    //方法同步，调用效率低

            if ( instance == null ){  //如果为null，创建对象

                 instance = new SingletonDemo02();

                 }

                 return instance ;

           }

     }

• 懒汉式总结：懒汉式适合单线程，多线程情况下如果在创建对象实例对象时不加上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();

                            }

                      }

                 }

            return instance ;

           }

     }

• 双重检测锁式总结：将同步内容放在了if内部，提高了执行的效率，不必每次调用对象时都进行同步，只有第一次才同步，创建了以后就没有必要了。

• 静态内部类实现：

public class SingletonDemo04 {  

            private static class singletonClassInstance{  //静态内部类

                  private static final SingletonDemo04 instance = new SingletonDemo04();

       }

            public static SingletonDemo04 getInstance(){

                  return singletonClassInstance. instance ;  //通过静态内部类名来调用内部类中的成员

           }

            private SingletonDemo04(){} //构造器私有

     }

• • 静态内部类方式总结：外部类无static属性，不会像饿汉式那样立即加载对象，只有真正调用getInstance(),才会加载静态内部类，加载类时是线程安全的。instance是static  final类型，保证了内存中只有这样一个实例存在，而且只被赋值一次，从而保证了线程安全性。兼并了高并发调用和延时加载的优势。而且调用效率高，并实现了延时加载。

• 枚举方式：

public enum SingletonDemo05 {

            INSTANCE ;  //此元素本身就是单例对象

            //添加自己需要的操作

            public void singletonOperation(){     

           }

     }

• 枚举方式总结：
  • 优点：实现简单，枚举本身就是单例模式，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞。
  • 缺点：无延时加载。

   初学菜鸟，大神请略过。