单例模式

什么是单例？

    在整个系统当中只允许一个实例存在。

单例的实现：

    （1）懒汉模式

    /**

    * 懒汉模式

    * 高并发时会有多个实例

    */

    public class Single1 {

        //静态私有实例

        private static Single1 single;

        //静态构造

        private Single1(){}

        public static Single1 getInstance(){

            if(single == null){

                single = new Single1();

            }

            return single;

        }

    }

    （2）饿汉模式

      /**

       *饿汉模式

       *在没有使用此单例时，该单例就已加载在内存中

       */

        public class Single2 {

            //类加载时就实例化对象

            private static final Single2 single = new Single2();

            public static Single2 getInstance(){

                //立即返回

                return single;

            }

        }

    （3）synchronized 同步方法

    /**

    *synchronized 同步方法式

    *每次获取单例时，都要先获取锁，性能影响较大

    */

    public class Single3 {

        private static Single3 single;

        private Single3(){}

        public static synchronized Single3 getInstance(){

            if(single == null){

                single = new Single3();

            }

            return single;

        }

}

    （4）双重检验锁

    /**

    *双重检验锁

    *每个线程最多只有在第一次的时候才会进入同步块

    */

    public class Single4 {

        private static volatile Single4 single;

        private Single4(){}

        public static synchronized Single4 getInstance(){

            //多线程直接访问，不做控制吗，不影响性能

            if(single == null){

                synchronized (Single4.class) {

                    if(single == null){

                        single = new Single4();

                    } 

                }

            }

            //如果不为null，不会影响性能，只有第一次才会影响性能

            return single;

        }

    }

    （5）静态内部类

    /**

    *静态内部类

    */

    public class Single5 {

        private Single5(){}

        public static synchronized Single5 getInstance(){

            return InnerClass.single;

        }

        //只有用到内部的静态属性时才会加载到虚拟机中

        private static class InnerClass{

            private static Single5 single = new Single5();

        }

    }

    （6）枚举

    /**

    *枚举

    */

    public enum Single6 {

        SINGLE_6;

        public Single6 getInstance(){

            return SINGLE_6;

        }

    }

单例的好处：

    （1）对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；

    （2）由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。