单例模式是我们面试中最常考到的设计模式。什么是设计模式呢？
设计模式是在计算机科学中，对面向对象设计中反复出现的问题的解决方案的描述。它是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
设计模式的目的在于可重用代码、让代码更容易被他人理解、提高代码的可靠性。它们通常描述了一组相互紧密作用的类与对象，提供了讨论软件设计的公共语言，使得熟练设计者的设计经验可以被初学者和其他设计者掌握。此外，设计模式还为软件重构提供了目标。
设计模式可以根据目的分为以下三类：
此外，根据范围，即模式主要是处理类之间的关系还是处理对象之间的关系，可分为类模式和对象模式两种。
单例模式保证一个类在程序中只存咋一个实例，而不会创建出多个实例。就像一个人只能有一个伴侣，而不能有多个伴侣一样。
虽然我们可以自己人为的控制该类只存在一个实例，但是我们人是最不能相信的生物，所以就需要使用计算机来对我们进行约束。当我们想要创建多个实例的时候，就需要编译器做出相应的反应：抛异常或者直接结束进程等。
在Java中实现单例模式可以有两种方式：
要想保证某个类只存在一个实例，其中一个很好的方法就是我们在定义这个类的时候就创建一个实例，并且这个实例是唯一的，当出了这个类的时候就不允许再创建该类的实例了。
class Singleton {
//定义类的时候就创建一个唯一的实例
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
因为出了这个类之后不能再创建该类的实例，并且我们需要获得在该类定义时创建的实例，所以可以使用一个静态的 getInstance 方法来获得这个唯一的实例。
虽然我们创建出了这个唯一的实例，但是应该怎样保证出了这个类之后不能再创建实例了呢？
我们都知道，每次创建一个实例的时候，都会调用该类的构造方法（如果你没有实现构造方法，编译器会为你默认创建一个无参数的构造方法），所以我们可以从这个构造方法入手：将构造方法改为私有的构造方法，只有在这个类中创建实例的时候才会创建成功，出了这个类之后，如果再创建第二个实例的时候，因为构造方法是私有的，所以就会创建失败。
class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
private Singleton() {}
}
当我们想要创建多个实例的时候，看看会发生什么情况：
当我们在写代码的时候，就会标红报错。然后我们再运行。
所以通过上面的饿汉模式实现单例模式是可以成功的，那么我们再来看看懒汉模式如何实现单例模式。
前面的为什么要叫做饿汉模式呢？因为饿汉模式定义类的时候，及创建了一个静态的实例，我们都知道静态的成员变量在类加载的时候就会被创建。这样就会导致不管我们用还是没用到这个实例，这个实例都会被创建，会造成内存和时间的浪费。而我们懒汉模式则很好的解决了这个问题，当定义类的时候，我们先不创建这个实例，而是先定义有这个实例，将这个实例赋值为null，当调用 getInstance 方法的时候，判断这个实例是否为 null，如果是 null 则创建实例，为这个实例申请空间和初始化，如果不为空则直接返回。
class Singleton2 {
private static Singleton2 instance = null;
public static Singleton2 getInstance() {
if(instance == null) {
instance = new Singleton2();
}
return instance;
}
private Singleton2() {}
}
但是这样就结束了吗？当然不是，既然是多线程的案例，那么我们肯定要考虑到线程的安全问题，那么接下来我们来看看如何解决单例模式中遇到的线程安全问题。
饿汉模式和懒汉模式是否都会在造成线程不安全问题吗？不是的，因为饿汉模式中只有对变量的判断而没有修改操作，但是懒汉模式中当判断 instance 是否为 null 之后，还会对 instance 做出修改，如果线程中存在判断和修改操作的时候，往往会出现线程不安全问题，所以只有懒汉模式会发生线程不安全的问题。
为了解决在判断和修改的过程中出现线程不安全的问题，需要在这个过程中进行加锁。
class Singleton2 {
private static Singleton2 instance = null;
public static Singleton2 getInstance() {
synchronized (Singleton2.class) {
if(instance == null) {
instance = new Singleton2();
}
}
return instance;
}
private Singleton2() {}
}
虽然我们在这个过程中进行了加锁，但是这个加锁过程并不是每次调用 getInstance 方法的时候都需要进行加锁，如果加锁频繁的话，那么我们这段代码就与高效率无缘了，只有当第一次调用 getInstance 方法的时候才需要加锁，那么我们又该如何优化这个频繁加锁问题呢？
class Singleton2 {
private static Singleton2 instance = null;
public static Singleton2 getInstance() {
if(instance == null) {
synchronized (Singleton2.class) {
if(instance == null) {
instance = new Singleton2();
}
}
}
return instance;
}
private Singleton2() {}
}
当再加上一个判断的时候，可能会有人问了，我为了创建一个实例使用了两个相同的判断，那么这个判断不显得多余吗？不多于，这两个判断完全不多余。
当实例已经不为 null 的时候，那么因为第一个判断，就不会进行加锁，而是直接返回 instance。
只有上面的两个优化是不够的，我们都知道造成线程不安全的问题还有指令重排序的问题。可以将创建实例的过程细分为三个步骤：
如果在创建实例的过程中发生了指令重排序，线程 t1 执行的本应该的顺序为1、2、3，但是却重排序成了1、3、2，那么当线程 t2 和线程 t1 并发执行的时候，就会将没有初始化的引用给返回，从而会出现比较严重的后果。
所以为了解决指令重排序而发生的线程不安全问题，我们需要使用 volatile 来保证内存的可见性，防止出现指令重排序的发生。
class Singleton2 {
private volatile static Singleton2 instance = null;
public static Singleton2 getInstance() {
if(instance == null) {
synchronized (Singleton2.class) {
if(instance == null) {
instance = new Singleton2();
}
}
}
return instance;
}
private Singleton2() {}
}
有了这三个优化，才真正保证了单例模式的安全进行。