单例模式优缺点

适用场景：
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：
1.需要频繁实例化然后销毁的对象。
2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3.有状态的工具类对象。
4.频繁访问数据库或文件的对象。
以下都是单例模式的经典使用场景：
1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
2.控制资源的情况下，方便资源之间的互相通信。如线程池等。
应用场景举例：
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.单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）
3.单例模式要素：
a.私有构造方法
b.私有静态引用指向自己实例
c.以自己实例为返回值的公有静态方法

要考虑的：
考虑多线程： 应用场合下必须小心使用。
考虑反射：比如持有单例的静态内部类为私有的时候，好处是在调用 SingletonHolder.instance 的时候，才会对单例进行初始化，而且通过反射，是不能从外部类获取内部类的属性的。（包含JSON的方式？）。
考虑序列化：需要的时候就要对序列话进行特殊的处理

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;
        }
}

还可以写成，更加快捷

    public static final class H {
        public static final AudioAgent Instance = new AudioAgent();
    }

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

总结：
一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测

后记：
还有呢，利用语言的诸多特性，大神们的创造力，还可以造出各种的单例模式：
枚举，天生受到了 JVM 的支持，而且既不用思考反射，也不用考虑多线程，对于自身的循环引用，本质上也是一个对象

public enum EnumSingleton {
        INSTANCE;
 }

但是劣势也很明显，而且也是由枚举类带来的：枚举类不支持继承和实现，所以在某些场景下不能使用。
使用Map的key-value对存储单例，并保证唯一，可以防止多线程和反射。

单例类需要继承怎么办：
　　说起单例模式，不管是什么方法实现的，有一点共性是不变的：不对外提供构造器，即将构造器的权限设为 private。
　　在一般情况下，以上方法是通用的，但是如果考虑到这个类的结构可能很复杂，会抽象出一个父类出来（不是指抽象类），那么如果这个父类也要保持单例，那么就不能将父类的构造器的权限设为 private 了。
　　这时，要保证做到以下两点：一个良好包结构设计 && 一个 protected 的构造器。
　　登记模式，是指所有的子类，都统一通过父类去构造，将自己的单例，存储在父类中。
　　相比于之前5种方式，更加倾向于构造单例，这种模式，重点在于管理单例。

其它的处理，不同的单例模式也有不同的适用场景，不是一定要用某种模式。比如Android UI中，有时就会使用懒汉式，因为UI是单线程的，所以不用考虑多线程问题，其它问题也没那么严重。LinkMovementMethod中的getInstance()。