GOF23中设计模式之单例设计模式

一、描述：

就是确保该类只有一个实例，且由内部自己创建，外部无法创建，只可以使用，并且提供一个访问该实例的全局访问点 

二、常见应用场景：

 1、windows的Task Manager（任务管理器）九十很典型的单例模式

2、windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例

3、操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统

4、Application也是单例的典型应用

5、在servlet编程中，每个Servlet也是单例

6、在spring MVC框架 / struts 1框架中，控制器对象也是单例

  7、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源

  8、应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加

三、单例模式的优点：

 1、由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如：读取配置、产生其他依赖的对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留在内存的方式来解决

 2、单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

四、常见的五种单例模式实现方式：

 1、懒汉式（线程安全，调用效率不高。但是可以延时加载）

/*
 * 单例设计模式
 * 懒汉式
 *   1.构造器私有化
 *   2.声明私有的静态属性
 *   3.对外提供访问属性的静态方法，同时确保该对象存在且唯一
 */
类初始化时不初始化这个对象（延时加载，真正用的时候再加载）

public class MyJvm1 {
     //类初始化时，不初始化这个对象（延时加载，真正使用的时候再加载）
     private static MyJvm1 instance;

     private MyJvm1(){}  //私有化构造器

     //方法加了同步，调用效率低
     public static synchronized MyJvm1 getInstance(){
           if(instance == null){
                instance = new MyJvm1();
           }
           return instance;
     }
}


class MyJvm2{
     private static MyJvm instance = null;

     private MyJvm() {               //私有化构造器
     }

     public static MyJvm getInstance(){
           if(null==instance){  //为了提高效率
                synchronized(MyJvm.class){      //加了同步，调用效率低
                      if(null==instance){        //为了安全
                           instance = new MyJvm();
                      }
                }
           }
           return instance;
     }
}

	 2、饿汉式（线程安全，调用效率高。但是不能延时加载）

/*
 * 单例设计模式
 * 饿汉式
 *   1.构造器私有化
 *   2.声明私有的静态属性，同时创建该对象
 *   3.对外提供访问属性的静态方
 *
 * 缺点：类加载时创建，类加载时不管用不用都会创建
 * 类在使用的时候加载
 */
class MyJvm2{
     //加载这个类  下面这个属性就会初始化
     private static MyJvm2 instance = new MyJvm2();
     private MyJvm2() {
     }
     public static MyJvm2 getInstance(){
           return instance;
     }
}

3、双重检测锁式（由于JVM底层内部模型原因，偶尔会出现问题，不建议使用）

/**
 * 双重检测锁实现
     
优点：这个模式将同步内容下放到if内部，提高了执行效率不必每次获取对象时都进行同步，只有第一次才同步，创建以后就没有必要了
缺点：由于编译器优化原因和jvm底层模型原因，偶尔会出现问题，不建议使用
 * @author Mr
 *
 */
public class SingletonDemo5 {
     private static SingletonDemo5 instance = null;

     public static SingletonDemo5 getInstance(){
           if(instance==null){
                SingletonDemo5 sc = null;
                synchronized (SingletonDemo5.class){
                      sc = instance;
                      if(sc ==null){
                           synchronized(SingletonDemo5.class){
                                 if(sc ==null){
                                      sc = new SingletonDemo5();
                                 }
                           }
                           return sc;
                      }
                }
           }
           return instance;
     }

     private SingletonDemo5(){}

}

	 4、静态内部类式（线程安全，调用效率高，但是，可以延迟加载）

/*
 * 静态内部类实现(也是一种懒加载模式)
 * 加载MyJvm3不会加载instance,要用的时候调用getInstance()便会加载该类，实例化该对象
 */
class MyJvm3{
     //延缓了加载的时机/
     private static class JVMholder{
           private static final MyJvm3 instance = new MyJvm3();

     }
     private MyJvm3() {
     }
     public static MyJvm3 getInstance(){  //不用加同步，效率高
           return JVMholder.instance;
     }
}
要点：
     外部类没有static属性，则不会像饿汉式那样立即加载对象
     只有真正调用getInstance()才会加载静态内部类，加载类时是天然线程安全的，instance是static final类型，保证了内存呢中只有这样一个实例存在，而且只被赋值一次，从而保证了线程的安全性
     兼备了并发高效调用和延迟加载的优势

	 5、枚举单例（线程安全，调用效率高，不能延时加载）

/**
 * 测试枚举式实现单例模式
 *
   枚举本身就是单例模式，有jvm提供安全保障
 * 避免了反射和反序列化的漏洞
 * 调用效率比较高
 *
 * 但是没有延时加载
 * @author Mr
 *
 */
public enum SingletonDemo4 {

     //这个枚举元素，本身就是单例对象
     INSTANCE;

     //添加自己需要的操作
     public void SingletonOperation(){}
}

五、单例的创建方式

	 1、构造器私有化

	 2、声明私有的静态属性

	 3、对外提供访问属性的静态方法，同时确保该对象存在且唯一