单例模式大家应该都不陌生，只要写过一些代码的，估计天天用，好处也自然不多说，有些对象创建一个就够了，比如数据库或者网络的连接，创建一个就够了。实现单例模式需要做到：
- 构造方法私有化
- 静态方法返回实例
- 当心多线程会创建多个实例
- 小心反序列化时会创建多个实例
方法一：类初始化的时候就创建
package disignpattern;
public class Singleton1 {
private static Singleton1 instance = new Singleton1();
private Singleton1() {
}
private static Singleton1 getInstance() {
return instance;
}
}
这种方式简单粗暴，但是缺点是用不到的时候也可能初始化。
方法二：使用的时候创建
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;
}
}
这里需要注意多线程的问题，需要将初始化的代码加一个锁，不过这里这种方式是一种粗粒度的加锁方式，效率不是很高，也可以这么写，效果一样：
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;
}
}
网上有一种针对这个的优化版本：
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（大部分时候）都不需要进入锁，因为锁比较耗时，所以这样是一个优化。
方式三：使用枚举创建
package disignpattern;
public enum Singleton5 {
INSTANCE;
public static Singleton5 getInstance() {
return INSTANCE;
}
}
这也是《java编程思想》里面推荐的单例模式实现方式，实现非常简单。
方法四：内部静态类
package disignpattern;
public class Singleton6 {
static class SingletonHolder {
private static Singleton6 instance = new Singleton6();
}
public static Singleton6 getInstance() {
return SingletonHolder.instance;
}
}
这个方式算是方法一的升级版，由于内部类在外部类被加载的时候不会立即被加载，只有当getInstance被调用时才加载内部类，所以算是对方法一的一个延迟版本。
一开始说到的反序列化是什么回事呢？
我们看一段代码：
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方法就行，至于原理，我们下回分析序列化的时候可以一起分析一下。
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;
}
}
