单例模式

单例模式

单例模式是最常见也是最简单的设计模式，在我们使用数据库连接时，往往便需要单例模式，这里整理一下常见的单例模式实现方法。

---

饿汉模式

顾名思义吗，饿汉模式就是在一开始便将单例实现，保证所有的实例都是同一个在最初便实现的单例。

    public class HungrySingleton{

        private static HungrySingleton singleton = new HungrySingleton();
        /*
            等同于
            private static HungrySingleton singleton;
            static{
                singleton = new HungrySingleton();
            }
        */
        //将构造器私有,确保得到实例防范的唯一
        private HungrySingleton(){}
        //提供唯一的获取实例方法
        public static HungrySingleton getInstance(){
            return HungrySingleton.getInstance();       
        }

    }

这里把唯一的实例设定为该类的静态属性，使得在该类声明的时候，便将唯一实例实现了，保证了线程安全的问题。但有个缺点就是，当初始化工作很大时，会对性能有影响。这种方法和使用静态代码块初始化的效果是一样的，不必多加区分。

懒汉模式

懒汉模式，就是在一开始并不实现唯一实例，而是在需要的时候再去实现它，实现了延迟加载的效果。

    public class LazySingleton{
        private static LazySingleton lazySingleton;
        //同样需要将构造器私有
        private LazySingleton(){}
        //在需要时，才会在getInstance方法中将其实例化
        public static LazySingleton getInstance(){
            if(lazySingleton == null){
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    }

懒汉模式把实现单例的步骤放到了getInstance()方法中，但这样就无法保证在多线程环境中实例的唯一性。如下：

    public class LazyTest extends Thread{
        @Override
        public void run(){
            System.out.println(LazySingleton.getInstance());
        }

        //可能会出现三个都不一样的结果
        public static void main(String[] args){
            new LazyTest().start();
            new LazyTest().start();
            new LazyTest().start();
        }
    }

这里可能会出现，三个都判断到当前的lazySingleton为null,因此三个线程都去实例化了lazySingleton，导致出现了三个不一样的实例。

线程安全的懒汉模式

为了保证在多线程环境中的安全，可以用synchronized来修饰，保证线程安全。

    public class LazySingleton{

            private static LazySingleton lazySingleton;

            //同样需要将构造器私有
            private LazySingleton(){}

            //在需要时，才会在getInstance方法中将其实例化
            public synchronized static LazySingleton getInstance(){
                if(lazySingleton == null){
                    lazySingleton = new LazySingleton();
                }   
                return lazySingleton;
            }
    }

这种方法虽然实现了线程安全的单例模式，但会出现整个getInstance()都被加锁，效率不高。因此可以使用下面这种双检查同步代码块的方式。

    public class LazySingleton{
        private static LazySingleton lazySingleton;
        //同样需要将构造器私有
        private LazySingleton(){}
        //在需要时，才会在getInstance方法中将其实例化
        public static LazySingleton getInstance(){

            if(lazySingleton == null){
                synchronized(LazySingleton.class){
                    if(lazySingleton == null){
                        lazySingleton = new LazySingleton();
                    }
                }
            }
            return lazySingleton;
        }
    }

这种双重检查模式，可以保证线程安全并且相比较上一中synchronized修饰方法的方式，锁的代码比较少，效率较高。

静态内置类实现单例模式

这种方法利用了静态内置类会延迟加载的机制，实现了线程安全的单例模式。

    public class StaticInnerSingleton{

        private static class Inner{
            private static StaticInnerSingleton singleton = new StaticInnerSingleton();
        }

        private StaticInnerSingleton(){}

        public static StaticInnerSingleton getInstance(){
            return Inner.singleton;
        }
    }

这种方式最重要的是将单例的实现放在了静态内置类里面，既可以保证延迟加载，又可以保证唯一性。唯一的缺陷是在序列化和反序列化中会出现不唯一的问题，可以参考下一篇(//TO-DO)解决此问题。

枚举实现单例模式

枚举实现单例模式是最简单，也是推荐的做法。

    public enum EnumSingleton{
        INSTANCE;

        private EnumSingleton(){
            System.out.println("私有的构造器");
        }
    }

这种方法可以保证只有一个实例，不怕序列化，而且是线程安全的，是最推荐使用的。

注意

推荐使用双重检查、静态内部类、枚举三种方式。在需要单例模式的时候，一定要把构造器私有化！

关于volatile

volatile关键字主要是保证它修饰的变量在不同线程间的可见性，即向虚拟机标注该变量是不稳定的，如果需要读取值，应
该向主内存中读取。因此，在我们没有用synchronized修饰的方法中，最好向不同线程都访问的变量前加上volatile！