2015-09-02 16:02:07
推荐一篇大神的文章，好久之前就看过这篇文章，而且本文的思路就来自这篇文章~其实有了大牛的文章，本文可写可不写，但是为了给自己总结一下，就写了~
http://callmegod.iteye.com/blog/1474441
单例的作用想必大家都知道，也一直在用，但是到底怎样的单例是“比较”完美的单例模式呢？我也不知道，但是我一直在寻找答案~
下面我简单总结一下单例吧，否则太乱了
Part 1：单例的几种实现方式
1. 恶汉式：指在类加载或者被初始化的时候，就创建一个单例对象，有好几个变种
第一种：类加载时创建对象
1 public class SingletonObj {
2 public static final SingletonObj INSTANCE = new SingletonObj();
3
4 private SingletonObj() {}
5 }
第二种：类加载时创建对象，但是对象是私有的，只能通过static的方法获取，好像更加“面向对象”
1 public class SingletonObj {
2 private static final SingletonObj INSTANCE = new SingletonObj();
3
4 private SingletonObj() {}
5
6 public static SingletonObj getInstance() {
7 return INSTANCE;
8 }
9 }
第三种：类初始化的时候创建对象
1 public class SingletonObj {
2 public static SingletonObj INSTANCE;
3
4 static {
5 INSTANCE = new SingletonObj();
6 }
7
8 private SingletonObj() {}
9
10 private static SingletonObj getInstance() {
11 return INSTANCE;
12 }
13 }
2. 懒汉式：使用时才创建对象，相比于恶汉式，这种方式会延迟加载。
第一种：线程不安全
1 public class SingletonObj {
2 public static SingletonObj INSTANCE;
3
4 private SingletonObj() {}
5
6 private static SingletonObj getInstance() {
7 if (INSTANCE == null) {
8 INSTANCE = new SingletonObj();
9 }
10 return INSTANCE;
11 }
12 }
第二种：线程安全，同时支持双重检查机制，这种也是最常见的单例模式(这种方式不推荐)
1 public class SingletonObj {
2 private static final Object sLocker = new Object();
3 public static SingletonObj INSTANCE;
4
5 private SingletonObj() {
6 }
7
8 private static SingletonObj getInstance() {
9 if (INSTANCE == null) {
10 synchronized (sLocker) {
11 if (INSTANCE == null) {
12 INSTANCE = new SingletonObj();
13 }
14 }
15 }
16 return INSTANCE;
17 }
18 }
这种方式有自己的弊端：有种说法，说是jdk1.5后才能保证达到单例效果，但是据我所知，这种方式来自C语音的双重检查机制，在Java中不见得能完全适用。
所以保险的加锁方式如下：
1 public class SingletonObj {
2 public static SingletonObj INSTANCE;
3
4 private SingletonObj() {
5 }
6
7 private synchronized static SingletonObj getInstance() {
8 if (INSTANCE == null) {
9 INSTANCE = new SingletonObj();
10 }
11 return INSTANCE;
12 }
13 }
3. 静态内部类方式：加锁的方式能做到线程安全，但是加锁会导致效率比较低，而这种方式既能满足线程安全的要求，而且效率比较高
1 public class SingletonObj {
2 private static class SingletonHolder {
3 public static final SingletonObj INSTANCE = new SingletonObj();
4 }
5
6 private SingletonObj() {
7 }
8
9 private static SingletonObj getInstance() {
10 return SingletonHolder.INSTANCE;
11 }
12 }
主要利用到静态类只会被JVM加载一次的特性~所以即便是多线程，也不会产生两个对象。这也是一种比较优雅的方式。
4. 《Effective Java》中提到一种更好的方法：单元素的枚举类型，大体实现如下(极棒的方式)
1 public enum SingletonEnum {
2 INTANCE(12, "Niu");
3
4 private int age;
5 private String name;
6 SingletonEnum(int age, String name) {
7 this.age = age;
8 this.name = name;
9 }
10
11 public void doSomething() {
12 System.out.println("SingletonEnum doSomething");
13 }
14 }
好处：线程安全，序列化/反序列化安全
弊端：失去了类的一些特性，因此不够流行
Part 2：
1. 上面提到了序列化，我们都知道，所谓序列化/反序列化就是对象和流之间的一种转换方式。因为对象是不能直接保存在硬盘或者通过网络传输的，但是序列化成流之后，原则上你想干嘛都行。但是单例的序列化比较特殊，我们知道，单例的作用就是保证JVM中只有一个对象，那么如何保证反序列化后的对象和序列化之前的是同一个对象呢？
1 public class SingletonCase implements Serializable {
2 private static class SingltonHolder {
3 public static final SingletonCase INSTANCE = new SingletonCase();
4 }
5
6 private int age;
7 private String name;
8 public static SingletonCase getInstance() {
9 return SingltonHolder.INSTANCE;
10 }
11
12 private SingletonCase() {
13 age = 133;
14 name = "David";
15 }
16
17 public int getAge() {
18 return age;
19 }
20
21 public String getName() {
22 return name;
23 }
24
25 private Object readResolve() {
26 return SingltonHolder.INSTANCE;
27 }
28 }
需要添加如上绿色代码，这是一个方法，返回值必须是Object，而不能是自己定义的对象。这个方法的作用是：每次反序列化完成前都会去调用readResolve()方法，将用原对象取代新创建出来的对象，这样就保证了序列化前后对象的唯一性。
单例的线程安全和序列化一直是个比较难缠的安全问题，所以单元素的枚举类型实现单例，既能保证线程安全性，又能保证序列化安全，可谓是一种perfect的方案~~
2. 关于transient
如果你不想某个成员变量被序列化，那么就可以用这个关键字来修饰~具体的使用大家问度娘。