单例模式应该是我们平时听过最多的设计模式，也是最简单的设计模式，面试的时候也经常会被问到，有的面试官还动不动让你手写一个单例模式。我们来一起了解一下单例模式吧。
一、什么是单例模式？
单例顾名思义就是单个的实例（对象）。单例模式属于创建型模式，它只涉及到单个的类，不通过new的方式创建对象，而是由类本身提供的方法创建和访问自己的对象，同时保证对象不会被多次创建，多次访问该方法时访问的是同一个对象。
二、单例模式的优缺点
优点：
1.有效的减少资源消耗。
2.方便对象状态的共享。
3.避免对资源的多重占用（如写文件操作时文件被多个对象占用）。
缺点：
1.因为状态共享，所以不适合同一个类需要在不同场景保存各自状态的情况。
2.不能继承（登记式除外），因此无法通过子类扩展功能。
3.违反了单一职责原则。因为实例化自身的职责是由自身完成的。
4.对于保存状态的单例对象，如果长时间未调用，对象有可能会被回收导致状态丢失。
三、单例模式的应用场景版本
单例模式的主要应用场景如下：
1.对象需要频繁创建、销毁的时候，例如被spring管理的bean默认都是单例模式，如果不是单例模式我们每次http请求的时候就需要创建很多对象，请求结束又要销毁这些对象。
2.创建对象需要时消耗时间较长或消耗资源较多且使用较频繁的对象。例如一些从文件读取数据的配置类，i/o操作就比较耗时耗资源。
3.需要全局共享状态或者资源的类，例如线程池、数据库连接池、保存了状态的工具类等。
四、单例模式的实现方式
1.懒汉式
懒汉式，在系统启动的时候不会实例化对象，只有在第一次获取对象时才会创建对象.
1.1线程不安全
这种实现方式适合用于单线程场景，多线程场景会创建多个实例。
public class Singleton1 {
private static Singleton1 instance;
private Singleton1() {
System.out.println("调用构造函数创建对象");
}
public static Singleton1 getInstance() {
if (instance == null) {
instance = new Singleton1();
}
return instance;
}
}
我们创建10个线程调用getInstance()方法进行测试，代码如下：
public static void main(String[] args) {
singleton1();
}
private static void singleton1(){
List<Thread> threads = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
threads.add(new Thread(Singleton1::getInstance));
}
threads.forEach(Thread::start);
}
测试结果如下：
Task :Test.main()
调用构造函数创建对象
调用构造函数创建对象
调用构造函数创建对象
调用构造函数创建对象
调用构造函数创建对象
可以看出构造函数被调用了多次，也就是说对象被多次实例化，并未实现单例。
1.2线程安全
下述方式对getInstance()方法加了锁，因此是线程安全的。加锁会影响效率，适用于getInstance()方法的性能对程序不是很重要的场景。
public class Singleton2 {
private static Singleton2 instance;
private Singleton2() {
System.out.println("调用构造函数创建对象");
}
public static synchronized Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
}
return instance;
}
}
我们创建10个线程调用getInstance()方法进行测试，代码如下：
public static void main(String[] args) {
singleton2();
}
private static void singleton2(){
List<Thread> threads = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
threads.add(new Thread(Singleton2::getInstance));
}
threads.forEach(Thread::start);
}
反复执行多次结果均如下：
Task :Test.main()
调用构造函数创建对象
可以看出对象只被创建了一次，因此时线程安全的。
2.饿汉式
饿汉式是在类被加载的时候就创建好了对象，因此是线程安全的，并且没有加锁，对不会影响程序效率，但是因为是在未使用之前加载的，所以会浪费一些内存。
public class Singleton3 {
private static Singleton3 instance = new Singleton3();
private Singleton3() {
System.out.println("调用构造函数创建对象");
}
public static Singleton3 getInstance() {
return instance;
}
}
3.双重校验锁
这种方式采用双锁机制，只锁了创建对象的一部分代码，因此在多线程情况下依然能保持高性能。下面的例子，有的童鞋可能觉得和方法上加锁性能差不多，如果在标记1和标记4处有一些耗时操作，那么第一个线程在创建对象的时候第二个线程已经可以进入方法在标记1处执行耗时操作了，等到第一个线程创建完对象两个线程又可以同时执行标记4处的耗时操作，如果是方法上加锁第二个线程必须等到第一个线程执行完标记1和标记4处的耗时操作才能再进入方法。
标记3处的第二个null判断的意义又是什么呢？此处的null判断非常关键，如果有两个线程同时执行到了标记2处，其中一个线程拿到了锁，创建了对象，释放锁后另一个线程拿到锁后如果没有标记3处的null判断，第二个线程就会再创建一个对象，就无法保证单例。
public class Singleton4 {
private volatile static Singleton4 instance = new Singleton4();
private Singleton4() {
System.out.println("调用构造函数创建对象");
}
public static Singleton4 getInstance() {
//标记1
if (instance == null){
//标记2
synchronized (Singleton4.class){
//标记3
if (instance==null){
instance = new Singleton4();
}
}
}
//标记4
return instance;
}
}
4.登记式/静态内部类
这种方式的功效跟双重校验锁一样，但实现方式更为简单。利用了classloader加载类的原理，保证了初始化Singleton5时只有一个线程，同时保证了了初始化Singleton5时它的静态内部类SingletonInner不会被加载，这样Singleton5对象(INSTANCE)也就不会被创建。
public class Singleton5 {
public static class SingletonInner {
public static final Singleton5 INSTANCE = new Singleton5();
}
private Singleton5() {
System.out.println("调用构造函数创建对象");
}
public static Singleton5 getInstance() {
return SingletonInner.INSTANCE;
}
}
5.枚举
这种方式利用了枚举类本身的特性，支持序列化机制可以在反序列化时避免重复创建对象，同时还能避免线程同步问题。但这种方式在实际使用中用的比较少。
public enum Singleton6 {
INSTANCE
//下面可以写一些方法
}
