单例模式

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。

这样的模式有几个好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

UML图：

首先我们写一个简单的单例类：

主要的几种实现方式：

    public class Singleton {  
      
        /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
        private static Singleton instance = null;  
      
        /* 私有构造方法，防止被实例化 */  
        private Singleton() {  
        }  
      
        /* 静态工程方法，创建实例 */  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
      
        /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
        public Object readResolve() {  
            return instance;  
        }  
    }  

 1、懒汉式

    /** 
     * 示例：单例--单例对象能保证在一个JVM中，该对象只有一个实例存在。 
     *  
     * 缺点：这种做法在多线程环境下，不安全 
     *  
     * 懒汉式 
     */  
      
    class Singleton {  
        /** 
         * 持有私有静态变量(也称类变量)，防止被引用 
         *  
         * 此处赋值为null，目的是实现延迟加载 (因为有些类比较庞大，所以延迟加载有助于提升性能) 
         */  
        private static Singleton instance = null;  
      
        /** 私有构造方法，防止被实例化 */  
        private Singleton() {  
      
        }  
      
        /** 静态工厂方法，创建实例 --只不过这里是创建自己，而且只能创建一个 */  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true，说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
    }  

2、饿汉式

    /** 
     * 饿汉式 
     */  
      
    class Singleton {  
        private static Singleton instance = new Singleton();  
      
        private Singleton() {  
      
        }  
      
        public static Singleton getInstance() {  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true，说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
      
    }  

如果考虑多线程，那么getInstance()方法要加同步synchronized，这时饿汉式比懒汉式要好，尽管资源利用率要差，但是不用同步。

  /** 
     * 饿汉式 
     */  
      
    class Singleton {  
        private static Singleton instance = new Singleton();  
      
        private Singleton() {  
      
        }  
      
        public static Singleton getInstance() {  
            return instance;  
        }  
      
        public void info() {  
            System.out.println("this is a test method...");  
        }  
    }  
      
    /** 
     * 客户端测试类 
     *  
     * @author Leo 
     */  
    public class Test {  
        public static void main(String[] args) {  
            Singleton s1 = Singleton.getInstance();  
            /** 
             * 调用普通方法 
             */  
            s1.info();  
            Singleton s2 = Singleton.getInstance();  
            /** 
             * 运行结果为true，说明s1、s2这两个类变量都指向内存中的同一个对象 
             */  
            System.out.println(s1 == s2);  
        }  
      
    } 

通过单例模式的学习告诉我们：

1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。

2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。

到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？

首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）

其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。

再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。

最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很大的关联，只是我们考虑问题的层面不同罢了。两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！