Java设计模式：单例模式

一、什么是单例模式

在我们实际的项目开发中，有时候我们只需要保留某一个类的一个对象，即实例化一次，这个时候我们需要考虑使用单例模式。

二、单例模式的特点

1. 单例模式只能有一个实例。
2. 单例类必须创建自己的唯一实例。
3. 单例类必须向其他对象提供这一实例。

三、单例模式与静态类的比较

在知道了什么是单例模式后，我想你一定会想到静态类，“既然只使用一个对象，为何不干脆使用静态类？”，这里我会将单例模式和静态类进行一个比较。

1. 单例可以继承和被继承，方法可以被override，而静态方法不可以。
2. 静态方法中产生的对象会在执行后被释放，进而被GC清理，不会一直存在于内存中。
3. 静态类会在第一次运行时初始化，单例模式可以有其他的选择，即可以延迟加载。
4. 单例对象往往存在于DAO层（例如sessionFactory），如果反复的初始化和释放，则会占用很多资源，而使用单例模式将其常驻于内存可以更加节约资源。
5. 静态方法有更高的访问效率。
   几个关于静态类的误解：
   误解一：静态方法常驻内存而实例方法不是。
   实际上，特殊编写的实例方法可以常驻内存，而静态方法需要不断初始化和释放。
   误解二：静态方法在堆(heap)上，实例方法在栈(stack)上。
   实际上，都是加载到特殊的不可写的代码内存区域中。

四、单例模式分类与实现

1.懒汉模式

package com.pattern.singleton;
 /**
  * 懒汉模式单例，没有考虑到线程安全问题
  */
public class SingletonSlacker {
  private static SingletonSlacker instance;

  private SingletonSlacker() {
  }
  public SingletonSlacker getInstance(){
     if (instance==null){
        instance=new SingletonSlacker();
     }
     return instance;
  }
}

没有考虑到线程安全，可能存在多个访问者同时访问，并同时构造了多个对象的问题。之所以叫做懒汉模式，主要是因为此种方法可以非常明显的lazy loading。
2.线程安全懒汉模式

package com.pattern.singleton;

/**
 * 线程安全的懒汉模式单例，缺点锁会消耗资源，效率低
 */
public class SingletonSecuritySlacker {
private static SingletonSecuritySlacker instance;

private SingletonSecuritySlacker() {
}
public synchronized SingletonSecuritySlacker getInstance(){
    if (instance==null){
        instance=new SingletonSecuritySlacker();
    }
    return instance;
}
}

3.饿汉模式

public class SingletonHungry {
private static SingletonHungry instance=new SingletonHungry();

private SingletonHungry() {
}
public SingletonHungry getInstance(){
    return instance;
}
}

4.静态内部类实现单例

public class SingletonStaticInner {
private static class SingletonInner {
    private static SingletonStaticInner instance = new SingletonStaticInner();
}

private SingletonStaticInner() {
}

public SingletonStaticInner getInstance() {
    return SingletonInner.instance;
}
}

5.用枚举写单例模式

enum SingletonEnum {
INSTANCE;

public void methods() {
    System.out.println("Done somethings!");
}
}

6.双重校验锁

public class SingletonDoubleCheck {
private volatile static SingletonDoubleCheck instance;

private SingletonDoubleCheck() {
    System.out.println("singleton has loaded!");
}

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

五、单例模式的应用场景

情景一：不需要维持任何状态，仅仅用于全局访问，此时更适合使用静态类。
情景二：需要维持一些特定的状态，此时更适合使用单例模式。