何为单例模式？单例模式即一个类只有一个实例并且该类有提供一个全局访问点。我们常常希望某个对象实例只有一个，不想要频繁地创建和销毁对象，浪费系统资源，这时候我们就要使用单例模式来获取类的实例。那怎么才能保证一个类是单例的呢？

我们可以先让一个类的构造方法给私有化，这样外部就不能通过new来创建类的对象，然后使用静态变量instance将实例保存起来，当需要使用该类的实例时只要调用getInatance()方法就可以得到该类的实例了。代码如下：

class SingleObject{
    private static SingleObject instance;

    private SingleObject(){
        
    }

    public static SingleObject getInstance(){
        if(instance == null){
            instance = new SingleObject();
            return instance;
        }
    }
}

但这样就足够了吗？如果只有单个线程运行程序的情况下，确实只会返回一个实例，但如果在多线程情况下，还是可能会产生多个实例，为什么？

举个例子，如果线程a在执行完getInstance方法里的if(instance == null)这句代码后就因为时间片用完变成阻塞状态，然后线程b执行getInstance方法时，此时instance实例还没有被new出来，所以线程b就执行if代码块里的代码创建了一个SingleObject对象，并赋值给instance，然后结束。线程a被唤醒后，继续执行之前的代码，也就是if代码块里的代码，这时就会产生SingleObject类的多个实例。

为了解决多线程情况下可能会产生多个实例的问题，我们可以使用synchronized关键字来给产生instance实例的代码块“加锁”解决这个问题：

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

通过synchronized关键字给创建实例的代码块“加锁”，同一时刻下，只有一个线程能够执行这个代码块里的代码，先执行这个代码块的线程发现没有instance实例后会创建instance实例，后面执行的线程会因为该实例已经存在而不会再去创建instance实例。

不过这并不是完美的解决方案，只要是锁，必然有性能损耗问题。而且对于上面的代码，其实我们只需要在线程第一次访问时加锁即可，之后并不需要锁，锁给我们带来了系统资源浪费。所以我们可以试着优化一下，如下面代码：

public class SingleObject {

    private static SingleObject instance;

    private SingleObject(){

    }

    public static SingleObject getInstance(){
        if (instance == null){
            synchronized (instance){
                if(instance == null){
                    instance = new SingleObject();
                    return instance;
                }
            }
        }
        return instance;
    }
}

我们可以在同步代码块外再加一个判断对象实例是否存的if语句，这样大部分线程执行完第一个if判断后就不用进入同步代码块中，而是直接获得instance对象，避免了加锁解锁的资源消耗。

经过我们使用双重判断的优化，看似已经完美解决了多线程情况下出现多个实例的问题，其实还留有一个隐患，这个隐患在第二个if判断的代码块里的instance = new SingleObject()这一句代码上，这句代码在JVM中不是一个原子操作，而是先有一条字节码指令来调用SingleObject对象的构造方法，然后下一条字节码指令将SingleObject对象的地址赋值给instance引用，但由于JVM的指令重排序优化，这两条指令的执行顺序会发生颠倒，即先将SingleObject对象的地址赋值给instance引用，再调用SingleObject对象的构造方法，这样会出现的情况就是，第一个线程在执行将SingleObject对象的地址赋值给instance引用赋值这条指令后，由于cpu时间片用完，而没有调用SingleObject对象的构造方法后就阻塞，接着第二个线程在执行第一个if判断时，此时的instance已经有值，直接return instance，但是此时的instance引用指向的对象并没有调用构造方法，所以是个空对象，这样就出现了问题。

那该如何解决这个问题呢，我们可以使用volatile关键字来修饰instance变量，代码如下：

public class SingleObject {

    private static volatile SingleObject instance;

    private SingleObject(){

    }

    public static SingleObject getInstance(){
        if (instance == null){
            synchronized (instance){
                if(instance == null){
                    instance = new SingleObject();
                    return instance;
                }
            }
        }
        return instance;
    }
}

volatile关键字可以禁用被修饰变量的读写操作指令的重排序，所以instance = new SingleObject()这一句代码将会按照先调用构造方法、再赋值引用的顺序执行，这样的话，当第一个线程进入阻塞状态时，第二个线程在第一个if判断时会因为instance的值为空而进入第一个if代码块中，但if代码块中的代码被synchronized给锁住，而此时锁又被第一个线程拥有，所以第二个线程会进入锁对象的等待队列中等待。而当第一个线程再次获得时间片时，它会继续实例化SingleObject对象并赋值给instance引用，然后结束并释放锁。而第二个线程被唤醒后拿到锁执行第二个if判断，因为instance已经有值，所以直接结束并释放锁。这样就完美地解决了多线程模式下可能会产生多个实例的问题。

上面创建单例对象的方式都是在 getInstance() 方法中创建实例，也就是说在要调用的时候才创建实例，这种方式被称为 “ 懒汉式 ” 我们也可以使用“饿汉式”单例模式 ，在类加载时就创建好了实例，代码如下：

class SingleObject{
    private static final SingleObject instance = new SingleObject();

    private SingleObject(){

    }

    public static SingleObject getInstance(){
        return instance;
    }
}

“饿汉式”的单例模式就是在单例类里面去定义和实例化一个静态的单例类对象，这样在单例类被加载时静态变量的单例对象就会被创建出来，不用去担心线程安全等问题。但是，这样做的坏处是不管你这个项目用不用到这个单例类对象，该对象都会被创建出来，可能会造成资源浪费。