单例模式大家应该都不陌生，只要写过一些代码的，估计天天用，好处也自然不多说，有些对象创建一个就够了，比如数据库或者网络的连接，创建一个就够了。实现单例模式需要做到：

  • 构造方法私有化
  • 静态方法返回实例
  • 当心多线程会创建多个实例
  • 小心反序列化时会创建多个实例
方法一：类初始化的时候就创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package disignpattern;
public class Singleton1 {
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {
    }
    private static Singleton1 getInstance() {
        return instance;
    }
}

这种方式简单粗暴，但是确定是用不到的时候也可能初始化。

方法二：使用的时候创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package disignpattern;
public class Singleton2 {
    private static Singleton2 instance = null;
    private Singleton2() {
    }
    private synchronized static Singleton2 getInstance() {
       if (instance == null) {
           instance = new Singleton2();
       }
        return instance;
    }
}

这里需要注意多线程的问题，需要将初始化的代码加一个锁，不过这里这种方式是一种粗粒度的加锁方式，效率不是很高，也可以这么写，效果一样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package disignpattern;
public class Singleton3 {
    private static Singleton3 instance = null;
    private Singleton3() {
    }
    private static Singleton3 getInstance() {
        synchronized (Singleton3.class) {
            if (instance == null) {
                instance = new Singleton3();
            }
        }
        return instance;
    }
}

网上有一种针对这个的优化版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package disignpattern;
public class Singleton4 {
    private static volatile Singleton4 instance = null;
    private Singleton4() {
    }
    private static Singleton4 getInstance() {
        if (instance == null) {
            synchronized (Singleton4.class) {
                if (instance == null) {
                    instance = new Singleton4();
                }
            }
        }
        
        return instance;
    }
}

这个方法有一个高大上的名词叫双重校验锁，instance被volatile修饰说明instance任何时候拿到的都是最新的值（可见性），所以如果instance不是null（大部分时候）都不需要进入锁，因为锁比较耗时，所以这样是一个优化。

方式三：使用枚举创建
1
2
3
4
5
6
7
8
9
10
11
package disignpattern;
public enum Singleton5 {
    INSTANCE;
    public static Singleton5 getInstance() {
        return INSTANCE;
    }
}

这也是《java编程思想》里面推荐的单例模式实现方式，实现非常简单。

方法四：内部静态类
1
2
3
4
5
6
7
8
9
10
11
12
13
package disignpattern;
public class Singleton6 {
    static class SingletonHolder {
        private static Singleton6 instance = new Singleton6();
    }
    public static Singleton6 getInstance() {
        return SingletonHolder.instance;
    }
}

这个方式算是方法一的升级版，由于内部类在外部类被加载的时候不会立即被加载，只有当getInstance被调用时才加载内部类，所以算是对方法一的一个延迟版本。

一开始说到的反序列化是什么回事呢？
我们看一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package disignpattern;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Singleton1 implements Serializable {
    private static final long sericlVersionUID = 1L;
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {
    }
    private static Singleton1 getInstance() {
        return instance;
    }
    public static void main(String[] args) throws Exception {
        FileOutputStream fileOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("/tmp/Singleton");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(instance);
        } finally {
            objectOutputStream.flush();
            objectOutputStream.close();
            fileOutputStream.close();
        }
        FileInputStream fileInputStream = null;
        ObjectInputStream objectInputStream = null;
        Singleton1 s = null;
        try {
            fileInputStream = new FileInputStream("/tmp/Singleton");
            objectInputStream = new ObjectInputStream(fileInputStream);
            s = (Singleton1) objectInputStream.readObject();
        } finally {
            objectInputStream.close();
            fileInputStream.close();
        }
        System.out.println( s == instance);
    }
}

这个输出false，也就是说反序列化的时候单例模式失效了，这是为啥？底层原理我看了网上资料说是反射，没有去读源码来深究，想想反射是可以实现的，这也是为啥单例模式会失效了，所以推荐的是枚举模式，枚举就算反射也没法创建多个实例。针对这个问题，我们可以通过在单例的类中实现一个readResolve方法就行，至于原理，我们下回分析序列化的时候可以一起分析一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package disignpattern;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Singleton1 implements Serializable {
    private static final long sericlVersionUID = 1L;
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {
    }
    private static Singleton1 getInstance() {
        return instance;
    }
    public static void main(String[] args) throws Exception {
        FileOutputStream fileOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("/tmp/Singleton");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(instance);
        } finally {
            objectOutputStream.flush();
            objectOutputStream.close();
            fileOutputStream.close();
        }
        FileInputStream fileInputStream = null;
        ObjectInputStream objectInputStream = null;
        Singleton1 s = null;
        try {
            fileInputStream = new FileInputStream("/tmp/Singleton");
            objectInputStream = new ObjectInputStream(fileInputStream);
            s = (Singleton1) objectInputStream.readObject();
        } finally {
            objectInputStream.close();
            fileInputStream.close();
        }
        System.out.println( s == instance);
    }
    private Object readResolve() {
        return instance;
    }
}