Java设计模式(二) -- 单例模式

    单例模式是Java中最广泛应用的设计模式之一，为创建对象提供了一种绝佳的方式。因此，在一些Java程序中，
一些管理器和控制器经常被设计为单例模式。

    这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯

一的对象的方式，可以直接访问，不需要实例化该类的对象。使用了单例模式之后，实例对象不会被重复创建，因此既节省

了创建实例对象所要的时间开销，又节约了内存空间，同时还避免了操作多个实例可能产生的逻辑错误。对于系统中只需要

一个全局对象的情况，也是一种很好的解决方式。

    单例模式有以下3个特点：
        1.只能创建一个实例
        2.只能自己创建自己的实例
        3.能够给其他所有的对象提供这一实例

    单例模式主要分为饿汉式和懒汉式，其中饿汉式指的是在类加载的时候就实例化，而懒汉式则是类加载时先不实例化，

当要用到实例对象时再进行初始化。

    单例模式有多种写法，下面将对单例模式的写法进行详细得介绍：

    1.饿汉式单例(立即加载)
    

    public class Singleton1 {
        private static Singleton1 singleton = new Singleton1();

        private Singleton1() {
        }

        public static Singleton1 getInstance() {
            return singleton;
        }
    }

    从上面可以看到，类的构造函数被修饰为private，避免了被外部类实例化，因此在Java虚拟机中，Singleton

的唯一实例只能通过getInstance()方法访问。同时，由于static的特性，在类加载的时候就对实例进行了创建，实

例会一直存在于程序的整个生命周期中，并且在类加载的时候只创建一次。但是，缺点也很明显，就是没有达到Lazy 

Loading的效果。即使至始至终没有外部类用到这个实例，Singleton1也会创建出实例，造成了内存的浪费。

 

    2.饿汉式单例(静态代码块)   

    public class Singleton2 {
        private static Singleton2 singleton;

        static {
            singleton = new Singleton2();
        }

        public Singleton2 getInstance() {
            return singleton;
        }
    }

    实际上这种方法和上面的方法很相似，把创建对象放在静态代码块中，在类加载时会初始化静态代码块，从而创建

实例，优缺点和上面的方法一样。

    

 

    3.懒汉式单例(线程不安全)

    public class Singleton3 {
        private static Singleton3 singleton = null;

        private Singleton3() {
        }

        public static Singleton3 getInstance() {
            if (singleton == null) {
                singleton = new Singleton3();
            }
            return singleton;
        }
    }

    可以看到，在需要用到实例对象时才创建对象，如果对象已经创建，则直接返回该对象而不是重新创建对象，这样

达到了按需创建对象的目的，有效减少内存损耗。但是这样会造成线程不安全，即当多个线程要同时创建实例时因为此

刻singleton == null，所以会给每个线程都创建一个实例，从而无法达到单例模式的效果。

 

    4.懒汉式单例(同步锁)   

    public class Singleton4 {
        private static Singleton4 singleton = null;

        private Singleton4() {
        }

        public static synchronized Singleton4 getInstance() {
            if (singleton == null) {
                singleton = new Singleton4();
            }
            return singleton;
        }
    }

    这个方法既达到了懒加载的效果，又解决了线程并发问题。但是有一个缺陷，就是运行效率太低下了。每次线程想

要创建实例时，调用getInstance()都要对类加同步锁。synchronized修饰的方法比一般的方法要慢得多，多次调

用getInstance()会造成性能损耗较大。

 

    5.懒汉式单例(双重校验)

    public class Singleton5 {
        private static Singleton5 singleton = null;

        private Singleton5() {
        }

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

    使用双重检验进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

    6.懒汉式单例(volatile)

    public class Singleton6 {
        private volatile static Singleton6 singleton = null;

        private Singleton6() {
        }

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

    volatile关键字排除了Java中的指令重排优化，确保了初始化Singleton和将对象地址赋给singleton字段的

顺序是确定的。

 

    7.懒汉式单例(静态内部类)    

    public class Singleton7 {
        private Singleton7(){}

        private static class InnerClass{
            private static Singleton7 singleton = new Singleton7();
        }
        public static Singleton7 getInstance(){
            return InnerClass.singleton;
        }
    }

    这种方式利用类加载机制确保只创建一个实例，因此不存在多线程并发问题。同时，在内部类里面去创建对象实

例，那么只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加

载。也就是说这种方式可以同时保证延迟加载和线程安全。

    

    8.枚举类 

    public enum Singleton8 {
        singleton;
        public void whateverMethod(){
        }
    }

     借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对

象。系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系

统性能。但是,当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他

开发人员造成困扰，特别是看不到源码的时候。