单例模式的定义为：一个类有且仅有一个实例，并且提供一个访问该实例的全局访问入口。
如何保证一个类只有一个实例对象：
1、将构造方法私有化（不能让外部随便就能创建对象）
2、自己创建对象（不能让别人创建，那就只能自己创建对象）
3、提供一个公共的获取对象的方法（全局访问入口）
饿汉式单例就是在类加载的时候就直接创建一个对象，而不管实际是否需要。
优点： 线程安全，因为类加载的时候已经创建了对象，所以调用的时候速度快。
缺点： 资源效率不高，不管用不用都创建，浪费内存空间。
public class SingletonHungry { // 1、在单例类的内部直接创建对象 private static final SingletonHungry instance = new SingletonHungry(); // 2、讲构造方法私有化 private SingletonHungry() { }; // 3、提供一个公有的构造方法，对外提供实例对象 public static SingletonHungry getInstance() { return instance; } }另一种写法：
public class SingletonHungry { // 1、在单例类的内部直接创建对象 private static final SingletonHungry instance; static { instance = new SingletonHungry(); } // 2、构造方法私有化 private SingletonHungry() { }; // 3、提供一个公有的构造方法，对外提供实例对象 public static SingletonHungry getInstance() { return instance; } }两种写法其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。
懒汉式单例就是在程序需要该对象的时候才实例化对象，实现懒加载。
public class SingletonLazy { // 1、在第一次调用的时候实例化自己 private static SingletonLazy instance = null; // 2、将构造方法私有化 private SingletonLazy() { }; // 3、提供一个公有的获取实例对象的方法 public static SingletonLazy getInstance() { // 判断是否存在该类的实例对象，不存在则创建 if (instance == null) { instance = new SingletonLazy(); } return instance; } }缺点：该单例虽然实现了延迟加载，但它是线程不安全的，并发环境下有可能有多个实例对象。
要实现线程安全，可以通过改造getInstance方法实现线程安全。
方法一：在getInstance()方法上加同步
public class SingletonLazy1 { private static SingletonLazy1 instance = null; private SingletonLazy1() { }; public static synchronized SingletonLazy1 getInstance() { if (instance == null) { instance = new SingletonLazy1(); } return instance; } }方法二：双重检查锁
在getInstance()方法中做两次null检查，这样不是任何时候都加锁，只有创建对象的时候才加锁，避免了每次都同步的性能损耗
public class SingletonLazy2 { //volatile关键字 private static volatile SingletonLazy2 instance = null; private SingletonLazy2() { }; public static SingletonLazy2 getInstance() { //不是任何时候都加锁，只有创建对象的时候才加锁 if (instance == null) { synchronized (SingletonLazy2.class) { if (instance == null) { instance = new SingletonLazy2(); } } } return instance; } }volatile关键字的作用：防止JVM指令重排优化，保证变量在多线程运行时的可见性
方法三：静态内部类
利用类的加载机制，他在内部类中去创建对象实例。这样的话只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会去创建单例对象，从而实现了懒汉式的延迟加载。
public class SingletonLazy3 { private static class LazyHolder { private static final SingletonLazy3 instance = new SingletonLazy3(); } private SingletonLazy3() { }; public static SingletonLazy3 getInstance() { return LazyHolder.instance; } }静态内部类和非静态内部类一样，不会因为外部类的加载而加载，只是在第一次使用的时候才加载，属于懒加载。
