单例模式（Singleton Pattern）

Ensure a class only has one instance,and provide a global point of access to it.
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
单例模式主要是为了避免因为创建了多个实例造成资源的浪费，且多个实例由于多次调用容易导致结果出现错误，而使用单例模式能够保证整个应用中有且只有一个实例。

• 定义：只需要三步就可以保证对象的唯一性
  • (1) 不允许其他程序用new对象
  • (2) 在该类中创建对象
  • (3) 对外提供一个可以让其他程序获取该对象的方法
• 对比定义：
  • (1) 私有化该类的构造函数
  • (2) 通过new在本类中创建一个本类对象
  • (3) 定义一个公有的方法，将在该类中所创建的对象返回
    ```
    /**
• 1.单例模式的饿汉式[可用]
• (1)私有化该类的构造函数
• (2)通过new在本类中创建一个本类对象
• (3)定义一个公有的方法，将在该类中所创建的对象返回
• 优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。
• 缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它
• 也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。
  */

public class SingletonEHan {

private SingletonEHan() {}

/**
 * 1.单例模式的饿汉式[可用]
 */
private static SingletonEHan singletonEHan = new SingletonEHan();

public static SingletonEHan getInstance() {
    return singletonEHan;
}

// SingletonEHan instance= SingletonEHan.getInstance();

/**
 * 2. 单例模式的饿汉式变换写法[可用]
 * 基本没区别
 */
private static SingletonEHan singletonEHanTwo = null;

static {
    singletonEHanTwo = new SingletonEHan();
}

public static SingletonEHan getSingletonEHan() {
    if (singletonEHanTwo == null) {
        singletonEHanTwo = new SingletonEHan();
    }
    return singletonEHanTwo;
}
//     SingletonEHan instance= SingletonEHan.getSingletonEHan();

}
}

- 内部类[推荐用]：

/**

• 内部类[推荐用]
• 这种方式跟饿汉式方式采用的机制类似，但又有不同。
• 两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
• 不同的地方:
• 在饿汉式方式是只要Singleton类被装载就会实例化,
• 内部类是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类

• 优点：避免了线程不安全，延迟加载，效率高。
  */
  public class SingletonIn {

  private SingletonIn() {
  }

  private static class SingletonInHodler {
  private static SingletonIn singletonIn = new SingletonIn();
  }

  public static SingletonIn getSingletonIn() {
  return SingletonInHodler.singletonIn;
  }
  }
  ```
• 枚举[推荐用]：

/**
 * . 枚举[极推荐使用]
 *
 * 这里SingletonEnum.instance
 * 这里的instance即为SingletonEnum类型的引用所以得到它就可以调用枚举中的方法了。
 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
 */

public enum SingletonEnum {

    instance;

    private SingletonEnum() {
    }

    public void whateverMethod() {

    }

    // SingletonEnum.instance.method();

}

-双重检验模式

class Singleton{
    private static volatile Singleton singleton;    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){                
                singleton = new Singleton();   //1
            }
        }
        return singleton;
    }
}

单例模式（Singleton Pattern）

原文：https://www.cnblogs.com/xiaohua7988/p/11616574.html