单例模式详解-优快云博客

单实例的创建目的：

希望对象只创建一个实例，并且提供一个全局的访问点。

1.这个对象把数值在多线程间传递d
2.当你需要传递的参数特别多，且全局很多地方都要用，甚至于需要修改

单实例的组成：

1.一个私有的构造函数（private smarty()），
2.一个私有的对象(你得那个第一行，囧)
3.一个共有的返回值为本类的对象的函数(instance())

存在的情况：

1.每次从getInstance()都能返回一个且唯一的一个对象。
2.资源共享情况下，getInstance()必须适应多线程并发访问。
3.提高访问性能。
4.懒加载（Lazy Load），在需要的时候才被构造。

单实例的组成：

1.一个私有的构造函数（private smarty()），
2.一个私有的对象(你得那个第一行，囧)
3.一个共有的返回值为本类的对象的函数(instance())

存在的情况：

首先实现1中的单例模式A：
[java] view plaincopy
4.public class SingletonA {
5.
6. /**
7. * 单例对象实例
8. */
9. private static SingletonA instance = null;
10.
11. public static SingletonA getInstance() {
12. if (instance == null) { //line 12
13. instance = new SingletonA(); //line 13
14. }
15. return instance;
16. }
17.}

这个写法我们把四点需求从上往下检测，发现第2点的时候就出了问题，假设这样的场景：两个线程并发调用Singleton.getInstance()，假设线程一先判断完instance是否为null，既代码中的line 12进入到line 13的位置。刚刚判断完毕后，JVM将CPU资源切换给线程二，由于线程一还没执行line 13，所以instance仍然是空的，因此线程二执行了new Signleton()操作。片刻之后，线程一被重新唤醒，它执行的仍然是new Signleton()操作。所以这种设计的单例模式不能满足第2点需求。
下面我们继续

实现2中单例模式B：
[java] view plaincopy
4.public class SingletonB {
5.
6. /**
7. * 单例对象实例
8. */
9. private static SingletonB instance = null;
10.
11. public synchronized static SingletonB getInstance() {
12. if (instance == null) {
13. instance = new SingletonB();
14. }
15. return instance;
16. }
17.}

比起单例A仅仅在方法中多了一个synchronized修饰符，现在可以保证不会出线程问题了。但是这里有个很大（至少耗时比例上很大）的性能问题。除了第一次调用时是执行了SingletonKerriganB的构造函数之外，以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的，绝大部分的耗时都用在synchronized修饰符的同步准备上，因此从性能上说很不划算。

实现3单例模式C：
[java] view plaincopy
4.public class SingletonC {
5.
6. /**
7. * 单例对象实例
8. */
9. private static SingletonKerriganD instance = null;
10.
11. public static SingletonC getInstance() {
12. if (instance == null) {
13. synchronized (SingletonC.class) {
14. if (instance == null) {
15. instance = new SingletonC();
16. }
17. }
18. }
19. return instance;
20. }
21.}
看起来这样已经达到了我们的要求，除了第一次创建对象之外，其他的访问在第一个if中就返回了，因此不会走到同步块中。已经完美了吗？
我们来看看这个场景：假设线程一执行到instance = new SingletonKerriganD()这句，这里看起来是一句话，但实际上它并不是一个原子操作（原子操作的意思就是这条语句要么就被执行完，要么就没有被执行过，不能出现执行了一半这种情形）。事实上高级语言里面非原子操作有很多，我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现，这句话被编译成8条汇编指令，大致做了3件事情：
1.给Kerrigan的实例分配内存。
2.初始化Kerrigan的构造器
3.将instance对象指向分配的内存空间（注意到这步instance就非null了）。
但是，由于Java编译器允许处理器乱序执行（out-of-order），以及JDK1.5之前JMM（Java Memory Medel）中Cache、寄存器到主内存回写顺序的规定，上面的第二点和第三点的顺序是无法保证的，也就是说，执行顺序可能是1-2-3也可能是1-3-2，如果是后者，并且在3执行完毕、2未执行之前，被切换到线程二上，这时候instance因为已经在线程一内执行过了第三点，instance已经是非空了，所以线程二直接拿走instance，然后使用，然后顺理成章地报错，而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来，真是一茶几的杯具啊。
DCL的写法来实现单例是很多技术书、教科书（包括基于JDK1.4以前版本的书籍）上推荐的写法，实际上是不完全正确的。的确在一些语言（譬如C语言）上DCL是可行的，取决于是否能保证2、3步的顺序。在JDK1.5之后，官方已经注意到这种问题，因此调整了JMM、具体化了volatile关键字，因此如果JDK是1.5或之后的版本，只需要将instance的定义改成“private volatile static SingletonKerriganD instance = null;”就可以保证每次都去instance都从主内存读取，就可以使用DCL的写法来完成单例模式。当然volatile或多或少也会影响到性能，最重要的是我们还要考虑JDK1.42以及之前的版本，所以本文中单例模式写法的改进还在继续。
代码倒越来越复杂了，现在先来个返璞归真，根据JLS（Java Language Specification）中的规定，一个类在一个ClassLoader中只会被初始化一次，这点是JVM本身保证的，那就把初始化实例的事情扔给JVM好了.

实现4单例模式D:
[java] view plaincopy
4.public class SingletonD {
5.
6. /**
7. * 单例对象实例
8. */
9. private static SingletonD instance = new SingletonD();
10.
11. public static SingletonD getInstance() {
12. return instance;
13. }
14.}

这种写法不会出现并发问题，但是它是饿汉式的，在ClassLoader加载类后Kerrigan的实例就会第一时间被创建，饿汉式的创建方式在一些场景中将无法使用：譬如实例的创建是依赖参数或者配置文件的，在getInstance()之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。
可带参数单例模式E:
[java] view plaincopy
4.public class SingletonE {
5.
6. private static class SingletonHolder {
7. /**
8. * 单例对象实例
9. */
10. static final SingletonE INSTANCE = new SingletonE();
11. }
12.
13. public static SingletonE getInstance() {
14. return SingletonHolder.INSTANCE;
15. }
16.}

这种写法仍然使用JVM本身机制保证了线程安全问题；由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖JDK版本。
当然，用户以其它方式构造单例的对象，如果设计者不希望这样的情况发生，则需要做规避措施。其它途径创建单例实例的方式有：
1.直接new单例对象
2.通过反射构造单例对象
3.通过序列化构造单例对象。
对于第一种情况，一般我们会加入一个private或者protected的构造函数，这样系统就不会自动添加那个public的构造函数了，因此只能调用里面的static方法，无法通过new创建对象。
对于第二种情况，反射时可以使用setAccessible方法来突破private的限制，我们需要做到第一点工作的同时，还需要在在 ReflectPermission("suppressAccessChecks") 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现。
对于第三种情况，如果单例对象有必要实现Serializable接口（很少出现），则应当同时实现readResolve()方法来保证反序列化的时候得到原来的对象。

终极版单例模式F:
[java] view plaincopy
4.public class SingletonF implements Serializable {
5.
6. private static class SingletonHolder {
7. /**
8. * 单例对象实例
9. */
10. static final SingletonF INSTANCE = new SingletonF();
11. }
12.
13. public static SingletonF getInstance() {
14. return SingletonHolder.INSTANCE;
15. }
16.
17. /**
18. * private的构造函数用于避免外界直接使用new来实例化对象
19. */
20. private SingletonF() {
21. }
22.
23. /**
24. * readResolve方法应对单例对象被序列化时候
25. */
26. private Object readResolve() {
27. return getInstance();
28. }
29.}

2、android中源码单例模式举例
1、日历模块
App路径:packages/providers/CalendarProvider
文件:packages/providers/CalendarProvider/src/com/android/provider/calendar/CalendarDatabaseHelper.java
单例代码：
[java] view plaincopy
private static CalendarDatabaseHelper sSingleton = null;
public static synchronized CalendarDatabaseHelper getInstance(Context context) {
if (sSingleton == null) {
sSingleton = new CalendarDatabaseHelper(context);
}
return sSingleton;
}
可以看出，这是用到了2中的单例模式B.

2.Collator类
文件:libcore/luni/src/main/java/com/ibm/icu4jni/text/Callator.java
libcore/luni/src/main/java/com/ibm/icu4jni/text/RuleBasedCallator.java
单例代码：
[java] view plaincopy
public static Collator getInstance(Locale locale) {
return new RuleBasedCollator(locale);
}
p;
[java] view plaincopy
RuleBasedCollator(Locale locale) {
m_collator_ = NativeCollation.openCollator(locale.toString());
}

[java] view plaincopy
static native int openCollator(String locale);

这就是上面给出的单例模式E，可带参数的单例模式

3.Editable类
文件:frameworks/base/core/java/android/text/Editable.java
[java] view plaincopy
private static Editable.Factory sInstance = new Editable.Factory();

/**
* Returns the standard Editable Factory.
*/
public static Editable.Factory getInstance() {
return sInstance;
}

可见这是单例模式D是实例应用
4.AccessibilityManager类
文件:frameworks/base/core/java/android/view/accessibility/AccessibilityManager.java
[java] view plaincopy
public static AccessibilityManager getInstance(Context context) {
synchronized (sInstanceSync) {
if (sInstance == null) {
sInstance = new AccessibilityManager(context);
}
}
return sInstance;
}

这是单例模式C的应用。
android使用单例模式的地方很多，特别是数据库创建时，就会使用到单例模式。因每种单例模式试用场景不一样，所以android在不同地方使用了不同的单例模式实现方式。
[java] view plaincopy

getinstance 与new 的区别：

1、new 一定要生成一個新對象，分配内存；getInstance（）则不一定要再次创建，它可以把一个已存在的引用给你使用，效能上优于new。

2、new 创建后只能当次使用，而getInstance（）可以跨栈区域使用，或者远程跨区域使用。所以getInstance（）通常是创建static静态实例方法的。

1.new的使用:
如Object_object=new Object()，这时候，就必须要知道有第二个Object的存在，而第二个Object也常常是在当前的应用程序域中的，可以被直接调用的

2.GetInstance的使用:
在主函数开始时调用，返回一个实例化对象，此对象是static的，在内存中保留着它的引用，即内存中有一块区域专门用来存放静态方法和变量，可以直接使用，调用多次返回同一个对象。

3.两者区别对照:
大部分类(非抽象类/接口/屏蔽了constructor的类)都可以用new，new就是通过生产一个新的实例对象，或者在栈上声明一个对象，每部分的调用用的都是一个新的对象。
getInstance是少部分类才有的一个方法，各自的实现也不同。getInstance在单例模式(保证一个类仅有一个实例，并提供一个访问它的全局访问点)的类中常见，用来生成唯一的实例，getInstance往往是static的。

(1)对象使用之前通过getinstance得到而不需要自己定义，用完之后不需要delete；

(2)new一定要生成一个新对象，分配内存；getInstance()则不一定要再次创建，它可以把一个已存在的引用给你使用，这在效能上优于new；

(3)new创建后只能当次使用，而getInstance()可以跨栈区域使用，或者远程跨区域使用。所以getInstance()通常是创建static静态实例方法的