Java 设计模式之单例模式

概念：

单例模式：一个类中只有一个实例。

一个类有且仅有一个实例，而且提供了一个全局的访问点。

使用该模式的原由：

　　当咱们在浏览网站时，有些网站会显示“当前在线人数”。一般，实现这个功能的办法是将登录的每个IP存储在一个内存、文件或者数据库中，每多一个IP，就实现“+1”。通常就是用一个方法，好比add()，实现“+1”的功能，好比用“update”语句，先获取数据库中存储的数据，再+1，更新数据库中的数据，,而后保存；显示在页面时，再经过另外的方法获取数据库中的数据便可。可是，当多个用户同时登录时，若是每个都要new一个对象，而后再经过“对象.方法名”调用执行add()方法，再将数据存储到数据库中，这样就会致使多个用户没法将实际的用户数据准确的记录到数据库中。因此，把这个计数器设计为一个全局对象（全部人都使用这一个对象，而不是用一个，new一个），全部人都共用同一份数据，就能够避免相似的问题，这就是咱们所说的单例模式的其中的一种应用。

 

一样的，还有其余场景中，也会遇到类似的情景，使用到相似的思路。好比：

　　 1.外部资源：每台计算机有若干个打印机，但只能有一个PrinterSpooler，以免两个打印做业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件 
　　 2. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想一想看，是否是呢，你能打开两个windows task manager吗？ 不信你本身试试看哦~ 
　　 3. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程当中，回收站一直维护着仅有的一个实例。 
　　 4. 网站的计数器，通常也是采用单例模式实现，不然难以同步。 
　　 5. 应用程序的日志应用，通常都何用单例模式实现，这通常是因为共享的日志文件一直处于打开状态，由于只能有一个实例去操做，不然内容很差追加。 
　　 6. Web应用的配置对象的读取，通常也应用单例模式，这个是因为配置文件是共享的资源。 
　　 7. 数据库链接池的设计通常也是采用单例模式，由于数据库链接是一种数据库资源。数据库软件系统中使用数据库链接池，主要是节省打开或者关闭数据库链接所引发的效率损耗，这种效率上的损耗仍是很是昂贵的，由于何用单例模式来维护，就能够大大下降这种损耗。 
　　 8. 多线程的线程池的设计通常也是采用单例模式，这是因为线程池要方便对池中的线程进行控制。 
　　 9. 操做系统的文件系统，也是大的单例模式实现的具体例子，一个操做系统只能有一个文件系统。 
　　 10. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，全部的HttpModule都共享一个HttpApplication实例。

 

总结起来，单例模式的通常应用场景为：

　　  1.须要频繁实例化而后销毁的对象。

　　  2.建立对象时耗时过多或者耗资源过多，但又常常用到的对象。

　   3.有状态的工具类对象。

　　  4.频繁访问数据库或者文件的对象。

　　  5.资源共享的状况下，避免因为资源操做时致使的性能或损耗等。如上述中的日志文件、应用配置等。

　　  6.控制资源的状况下，方便资源之间的互相通讯。如线程池等。

 

特色：

一、单例类只能有一个实例；

二、单例类必须本身建立本身的惟一实例；

三、单例类必须给全部其余对象提供这一实例

 

单例模式要素： 
   1.私有构造方法 
   2.私有静态引用指向本身实例 
   3.以本身实例为返回值的公有静态方法

 

实现单例模式的三种方法：

1.饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法） 

/**
* 饿汉式（推荐）
*
*/
public class Test {
        private Test() {
        }
        public static Test instance = new Test();
        public Test getInstance() {
                return instance;
        }
}

优势 
    1.线程安全 
    2.在类加载的同时已经建立好一个静态对象，调用时反应速度快 
缺点 
    资源效率不高，可能getInstance()永远不会执行到，但执行该类的其余静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化 


2.懒汉式：单例实例在第一次被使用时构建，延迟初始化。 

class Test {
        private Test() {
        }
        public static Test instance = null;
        public static Test getInstance() {
                if (instance == null) {
              //多个线程判断instance都为null时，在执行new操做时多线程会出现重复状况
                        instance = new Singleton2();
                }
                return instance;
        }
}

优势 
    避免了饿汉式的那种在没有用到的状况下建立事例，资源利用率高，不执行getInstance()就不会被实例，能够执行该类的其余静态方法。 
缺点 
    懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事建立多个实例，并且这多个实例不是同一个对象，虽而后面建立的实例会覆盖先建立的实例，可是仍是会存在拿到不一样对象的状况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用没必要要的同步开销大。 

3.双重检测 

class Test {
        private Test() {
        }
        public static Test instance = null;

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

优势 
    资源利用率高，不执行getInstance()就不被实例，能够执行该类其余静态方法 
缺点 
    第一次加载时反应不快，因为java内存模型一些缘由偶尔失败 


4.静态内部类 

class Test {
        private Test() {
        }

        private static class SingletonHelp {
                static Test instance = new Test();
        }

        public static Test getInstance() {
                return SingletonHelp.instance;
        }
}

优势 
    资源利用率高，不执行getInstance()不被实例，能够执行该类其余静态方法 
缺点 
    第一次加载时反应不够快 

总结： 
    通常采用饿汉式，若对资源十分在乎能够采用静态内部类，不建议采用懒汉式及双重检测