单例设计模式(懒汉式,饿汉式,枚举式,双重检测锁式,静态内部类式)

设计模式分类:

1：创建型模式：

单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式；

2：结构型模式：

适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式

3：行为型模式：

模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，

解释器模式，状态模式，策略模式，职责链模式，访问者模式。

 

单例模式应用场景：

windows的task manager(任务管理器)就是很典型的单例模式，windows的recycle bin(回收站)也是典型的单例应用，在整个系统运行过程中，回收站一直维护仅有的一个实例。

项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件数据，每次new一个对象去读取，应用程序的日志应用，一般都可用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

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

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

Application也是单例的典型应用(servlet编程中会涉及到)在spring中，每个bean默认就是单例的，这样做的优点是spring容器可以管理

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

在spring mvc框架/struts1框架中，控制器对象也是单例

单例模式的实现（5种）

常用:

饿汉式(线程安全，调用效率高，但是不能延时加载)

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

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

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

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

 

 

public class Test02 {
/**
  * 单例模式，懒汉式，线程安全
  */ public static class Singleton {
         private final static Singleton INSTANCE = new Singleton();
         private Singleton() {
          }
          public static Singleton getInstance() {
             return INSTANCE;
         }
     }
/**
 * 单例模式，饿汉式，线程不安全
 */
    public static class Singleton2 {
         private static Singleton2 instance = null;
         private Singleton2() {
         }
         public static Singleton2 getInstance() {
             if (instance == null) {
                 instance = new Singleton2();
              }
         return instance;
         }
    }
/**
* 单例模式，饿汉式，线程安全，多线程环境下效率不高
*/
public static class Singleton3 {
   private static Singleton3 instance = null;
     private Singleton3() {
     }
     public static synchronized Singleton3 getInstance() {
         if (instance == null) {
             instance = new Singleton3();
         }
     return instance;
     }
}
 /**
 * 单例模式，懒汉式，变种，线程安全
 */
 public static class Singleton4 {
    private static Singleton4 instance = null;
      static {
        instance = new Singleton4();
      }
      private Singleton4() {
      }
      public static Singleton4 getInstance() {
        return instance;
      }
}

 

 

/**

* 枚举单例模式

* @author Administrator

*

*/

public enum SingleTonDemo4 {

INSTANCE; //虽然只有一行

}

 

public class TestEnum {

//测试枚举单例

    public static void main(String[] args) {

      SingleTonDemo4 instance1 = SingleTonDemo4.INSTANCE;

      SingleTonDemo4 instance2 = SingleTonDemo4.INSTANCE;

      SingleTonDemo4 instance3 = SingleTonDemo4.INSTANCE;

      System.out.println(instance1 == instance3);

    }

}

 

/**

* 静态内部类式单例设计模式

* @author Administrator

*

*/

public class SingleTonDemo3 {

//只会被加载一次，线程安全

          static class Nested {

                private static SingleTonDemo3 instance = new SingleTonDemo3();

         }

         private SingleTonDemo3() {

         }

         public static SingleTonDemo3 getInstance() {

                return Nested.instance;

         }

}

 

/**

* 双重检测锁式单例设计模式

* @author Administrator

*

*/

public class SingleTonDemo5 {

 

private static volatile SingleTonDemo5 instance;

            private SingleTonDemo5() {

            }

            //getInstance()方法检查了两次来判断INSTANCE是否为null，这就是为什么叫双检索的原因，

            //记住双检索在java5之前是有问题的，但是java5在内存模型中有了volatile变量之后就没问题了

            public static SingleTonDemo5 getInstance(){

                  if(instance == null){

                        synchronized(SingleTonDemo5.class){

                                  if(instance == null){

                                          instance = new SingleTonDemo5();

                                  }

                        }

                  }

                  return instance;

            }

}