单例模式

解决的问题：可以保证一个类在内存中的对象唯一性

对象唯一性

1.不允许其他程序用new创建对象。

2.在该类创建一个本类实例。

3.对外提供一个方法让其他程序可以获得该对象。

步骤：

1.私有化该类构造函数。

2.通过new在本类中创建一个本类对象。

3.定义一个共有的方法，将创建的对象返回。

饿汉式：（饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。）

public class Singleton {// 在类初始化时，已经自行实例化private Singleton() {};private static final Singleton single = new Singleton();public static Singleton getInstance() {return single;}}

懒汉式：（线程不安全）

public class Singleton {// 在第一次调用的时候实例化自己private Singleton() {};private static Singleton single = null;public static Singleton getInstance() {if (single == null) {single = new Singleton();}return single;}}

懒汉式（在getinstance上加上synchroized）

public class Singleton {// 在第一次调用的时候实例化自己private Singleton() {};private static Singleton single = null;public static synchronized Singleton getInstance() {if (single == null) {single = new Singleton();}return single;}}

懒汉式（双重锁定）

public class Singleton {// 在第一次调用的时候实例化自己private Singleton() {};private static Singleton single = null;public static Singleton getInstance() {if (single == null) {synchronized (Singleton.class) {if (single == null) {single = new Singleton();}}}return single;}}

懒汉式（静态内部类）（推荐）

public class Singleton {private static class LazyHolder {private static final Singleton INSTANCE = new Singleton();}private Singleton() {}public static final Singleton getInstance() {return LazyHolder.INSTANCE;}}

主要区别：

线程安全：

饿汉式天生就是线程安全的。

懒汉式本身是非线程安全的。

资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，

但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，

如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。