设计模式——创建型模式（单例模式）

Java开发中的23中设计模式可以分为三类——1.创建型模式 2.结构型模式 3.行为型模式。今天我们来了解一下其中的创建型模式。

创建型模式包含：单例模式、原型模式、工厂方法模式、抽象工厂模式、建造者模式。

单例模式（说着简单，做起来复杂）

单例模式是我们经常遇到也经常使用的一种模式 我对它的理解是在程序运行过程中有且仅可以有一个类的实例存在。

单例模式的实现常用的方式可以分为两种一种是懒汉式另一种是饿汉式，下面通过代码来了解一下具体的实现方式。

饿汉式：
顾名思义就是在类加载的过程中就已经创建好了相应的静态对象供程序使用，该对象不会再改变，由于实例化和赋值过程在类加载的时候完成所以这种方式是线程安全的。但是这种方式也有个缺点就是不管你用不用都会创建出实例。一般情况下推荐使用这种方式（原因：代码简单明了，无需考虑线程安全的问题）。

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

    /*构建私有化的构造方法，避免其他类通过new 来实例化*/
    private MySingleton() {
    }

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

懒汉式：
当需要使用的时候再去检查静态对象是否已经创建，如果没有则创建实例，反之则直接使用。这种方式需要注意的是线程安全的问题。需要对对象的实例化和赋值过程使用synchronized来加锁。
我们先不考虑线程安全的问题，来看一下简单的实现。

public class MySingleton {
    private static MySingleton instance;

    /*构建私有化的构造方法，避免其他类通过new 来实例化     */
    private MySingleton() {
    }

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

这就是懒汉式的简单实现，不过我们也能看出当出现多线程的情况的时候会出现什么问题——我们的instance可能会在同一时刻被赋值多个实例化对象，造成数据混乱的情况出现。试想一下，如果我们的程序是12306这样的应用，同一时刻有成千上万的人进行了同样的操作而由于我们的程序缺陷将会导致什么样的后果。所以我们来解决一下我们的这个程序缺陷，让它变成线程安全的。我们先对getInstance()这个方法使用synchronized 来上锁。

public class MySingleton {
    private static MySingleton instance;

    /*构建私有化的构造方法，避免其他类通过new 来实例化     */
    private MySingleton() {
    }

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

这样写虽然暂时解决了线程安全的问题，但是我们发现当多线程的情况下其他线程每次都会等待到当前线程调用完getInstance() 才会进入该方法，例如线程A正在持有getInstance()此时线程B也调用到了getInstance()方法，可是此时instance对象已经被赋值线程A在方法内也并没有执行任何操作，而线程B却要等到线程A调用完之后才会执行，之久让线程B白白浪费了一些时间。以此类推当有更多的线程访问到getInstance()这个方法时这样的浪费时间的等待，无疑就给我们的cpu带来了一定的压力。所以我们可不可以将synchronized 放在实例化和赋值的过程中而不是针对这个方法。来通过代码实现一下试试看。

public class MySingleton {
    private static MySingleton instance;

    /*构建私有化的构造方法，避免其他类通过new 来实例化     */
    private MySingleton() {
    }

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

以上我们将instance = new MySingleton();的过程使用了synchronized，这解决了cpu压力的问题，但是我们又发现，当线程A刚好执行到synchronized内部代码并且还没有执行完的时候此时线程B也执行到了synchronized这一行，所以线程B会等待线程A执行完之后进入到synchronized内部代码继续执行，可是这就又出现了线程安全的问题。怎么又出现了线程安全的问题呢？不要着急针对这个问题我们来分析一下，之所以线程B会走到synchronized内部是因为在我们的 if (instance == null)这个判读的时候线程A还没有实例化对象并赋值给instance，所以线程B才会进入if判读而停留在synchronized这一行等待线程A执行结束，而我们再想一想线程A执行完synchronized代码块后我们的instance是不是已经不为null了，所以当线程B进入synchronized代码块后我们其实就没有必要执行instance = new MySingleton();了，所以很简单我们只要在synchronized代码块内部的instance = new MySingleton();前再加一个 if (instance == null)的判断就可以了。

public class MySingleton {
    private static MySingleton instance;

    /*构建私有化的构造方法，避免其他类通过new 来实例化     */
    private MySingleton() {
    }

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

到此懒汉式的实现方式就了解完了。可是我们发现这种方式也并不是完美的，在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new MySingleton();语句是分两步执行的，而JVM又无法保证这两个操作的顺序，所以有可能出现当线程A执行到instance = new MySingleton();这个过程的时候JVM为instance赋了值分配了内存空间但是还没有实例化对象的情况，而此时线程B进入后由于instance已经被赋值所以线程B会直接返回结果，而此时线程B使用instance对象时发现它并没有被真正的实例化，导致程序出错。其实并没有十分完美的解决方式，只有最适合于你的解决方案。而这两种就是我实际开发中常用到的。当然除了以上所说的实现方式还有其他的实现方式比如通过使用内部类来实现的方式、枚举的方式... 你可以查阅其他的资料了解更多的实现方式。