单例设计模式

单利设计模式介绍

• 所谓类的单利设计模式，是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只能提供一个取得其对象实例的方法(静态方法)。
• 比如 Hibernate 的 Session Factory，他充当数据存储源的代理，并负责创建Session对象。Session Factory并不是轻量级的，一般情况下，一个项目通常只需要创建一个SessionFactory 就够了，这就会使用到单利模式。

  单利设计模式八种方式

  饿汉式（静态常量）

1. 构造器私有化
2. 类的内部创建对象
3. 向外部暴露一个接口 getInstance

• 案例： ```java class Singleton{ //私有化构造器 private Singleton(){} //类的内部创建对象 private final static Singleton instance = new Singleton(); //向外暴露一个接口 getInstance public static Singleton getInstance(){

    return instance;

  }

}

- 优缺点 说明
   - 优点：写法比较简单，就是在类装载的时候完成实例化。避免线程同步的问题。
   - 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果这个类从始至终从未使用过这个实例，则会造成内从浪费。
   - 这种方式基于 classloader 机制避免了线程同步的问题，不过， instance 在类加载时就实例化，在单利模式中大多都是调用getInstance 方法，但是导致类装载的原因有多种，因此不能确定有其他的方式(或者其他的静态方法)导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果。
- 结论：这种单例模式可用，可能会造成内从浪费。
<a name="mbGSD"></a>
#### 饿汉式（静态代码块）

1. 构造器私有化
1. 类的内部创建对象 使用静态代码块
1. 向外部暴露一个接口 getInstance
- 案例：

```java
class Singleton{
    //私有化构造器
    private Singleton(){}
    //类的内部创建对象
    private  static Singleton instance;
    static{
        instance = new Singleton();
    }
    //向外暴露一个接口 getInstance
    public static Singleton getInstance(){
        return instance;
    }

}

• 优缺点：
  • 和饿汉式(静态常量)一致，都会导致内存浪费。
  • 但是，类实例化的过程放在静态代码块中，类在装载的时候，执行静态代码块中的代码，初始化类的实例。

结论：这种单例模式可用，可能会造成内从浪费。

懒汉式（线程不安全）

1. 构造器私有化
2. 成员私有化

3. 向外部暴露一个接口 getInstance 创建单例对象 ```java class Singleton{ //私有化构造器 private Singleton(){} //成员私有化 private static Singleton instance;

   //向外暴露一个接口 getInstance public static Singleton getInstance(){

    if(instance==null){
        instance = new Singleton();
    }
    return instance;
   

   }

}

- 优缺点说明
   - 起到了lazy loading 的效果，但是只能在单线程下使用。
   - 如果多线程下，一个线程进入了  if(instance==null) 判断语句块，还未来的及往下执行，另一个线程也通过了这个语句块，这是就会**产生多个实例**。所以在多线程环境不能使用这种方式
- **结论：在实际开发中，不要使用这种方式**。
<a name="QGR4n"></a>
#### 懒汉式（线程安全，同步方法）

1. 构造器私有化
1. 成员私有化
1. 向外部暴露一个接口 getInstance 使用同步锁机制创建单例对象
```java
class Singleton{
    //私有化构造器
    private Singleton(){}
    //成员私有化
    private  static Singleton instance;

    //向外暴露一个接口 getInstance
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }

}

• 优缺点说明
  • 解决线程安全问题
  • 效率太低，每个线程在想获得类的实例的时候，执行 getInstance() 方法都需要进行同步。而其实这个方法只执行一次实例化代码块就够了，后面的想获得该类实例，直接 return 就行。方法进行同步效率太低。

• 结论：在实际开发中，不要使用这种方式。

  懒汉式（线程安全，同步代码块）

  ```java class Singleton{ //私有化构造器 private Singleton(){} //成员私有化 private static Singleton instance;

  //向外暴露一个接口 getInstance public static synchronized Singleton getInstance(){

    if(instance==null){
        synchronized(Singleton.class){
           instance = new Singleton();
        }
    }
    return instance;
  

  }

}

- 不推荐使用，线程不安全。
<a name="xaNN5"></a>
#### 双重检查

- 私有化构造器
- 私有化成员
- 提供一个静态公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
- 案例：

```java
class Singleton{
    private Singleton(){}
    private static volatile Singleton instance;
    public static Singleton getInstance(){
        //检查 instance 是否为null
        if(instance==null){
            synchronized(Singleton.class){
                if(instance==null){
                    instance = new Singleton();
                }
            }
             return instance;
        }
    }
}

• 优缺点说明：
  • double-check 概念是多线程开发中常用到的，如代码块中所示，我们进行了俩次 if(instance==null),这样就可以保证线程安全。
  • 实例化代码块只是用一次，后面再次访问时，判断 if(instance==null) 直接return 实例化对象，也避免的反复进行方法同步。
  • 线程安全：延迟加载；效率较高
• 结论：在实际开发中，推荐使用。

  静态内部类

1. 私有化构造器
2. 一个静态内部类，该类中有一个静态属性 Singleton
3. 提供一个静态公有方法，直接返回 SingletonInstance.INSTANCE

 class Singleton{
     private Singleton(){}
    private static class  SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
     public static synchronized Singleton getInstance(){
         return Singleton.INSTANCE;
     }
 }

• 优缺点说明
  • 采用类装载的机制来保证初始化实例时只有一个线程。
  • 静态内部类的方式在 Singleton 类被装载时并不会立即实例化，而是需要实例化是，调用 getInstance 方法，才会装载 SingletonInstance 类，完成实例化 Singleton 类。
  • 类的静态属性只会在第一次加载类的时候初始化，所以JVM 帮助我们保证线程的安全性，在类进行初始化时，别的线程无法进入。
  • 优点：避免线程不安全，利用静态内部类的特点实现延迟加载，效率高
  • 结论：效率高，推荐使用。

    枚举

1. 一个枚举类 Singleton
2. 成员 INSTANCE
3. 暴露一个方法

• 案例：

enum Singleton{
    INSTANCE;
    public void getInstance(){
        System.Out.Print("ff");
    }

}

• 优缺点说明：
  • 这借助JDK 1.5 中添加的枚举来实现单例模式。不仅能避免多线程问题，而且还能防止反序列化重新创建对象。
  • 这种方式 是 Effective JAVA 作者 Josh Bloch 提倡的方式
• 结论：推荐使用，能够避免多线程问题 和 防止反序列化重新创建对象。

  单利模式在jdk 应用的源码分析

1. 我们在JDK中，java.langRuntime 就是经典的单例模式(饿汉式)
2. 代码分析+debug源码+代码说明

单利模式的注意事项和细节说明

1. 单例模式保证 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建 销毁的的对象，使用单例模式可以提高系统性能。
2. 当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而 不是使用 new 对象。
3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时过多耗费资源过多(既：重量级对象)，但又经常使用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)