为了防止被“杀”了祭天，学点设计模式，并总结下还是有必要的。
一：理解
- 单例模式也称单件模式，它可以确保一个类只有一个实例，并提供一个全局访问点。
- 单例模式大致可以分成两类。第一类是在类加载时，就创建对象，并在每次请求新建对象时，都返回该对象；第二类是在第一次需要生成对象时才新建，在之后每次请求新建对象时都检查是否已经有存在的对象。
- 分别称为饿汉模式和懒汉模式。
二：例子
你是个富二代，你有很多女朋友。
情人节快到了，你为约哪个女朋友出来而发愁。
由于体力原因，你决定只约一个，可怎么才能保证呢。
于是，你叫来了程序员小菜帮忙。
小菜上来就敲了一通代码。
新建一个YueHui(约会)类，初始化时需要传入女朋友的编号。
public class YueHui {
private int numOfGirl;
public YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
}
你觉得小菜考虑得十分周到，考虑到你有太多女友，新建约会对象传入女朋友编号，而不用姓名。
然而，你发现每个女朋友都可以新建约会对象，莫非是小菜想要累死你不成。
于是你拿起了拳头，问小菜这是什么？
小菜吓得立马把构造函数改成了private私有的，然而你发现修改之后所有女朋友都新建不了约会对象了，洪荒之力无处安放啊。
你叹了一口气，语重心长地和小菜说道：小菜啊，这又不是你的节日，你怎么也变得这么心不在焉呢？
小菜觉得好有道理的样子，于是拿出自己多年不用的青轴，决定在七夕晚上放肆地啪啪啪一顿。
小菜想到可不可以用单例模式来解决这个虐狗的约会问题。
他有点犹豫，毕竟之前想到单例模式都只会想到该死的单身狗(damn single)，怎么能把这个模式用到高富帅约会的情景上呢。
不过他还是决定死马当活马医，含着眼泪写下了下面这段代码：
public class YueHui {
private int numOfGirl;
private YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
private static YueHui yueHui = new YueHui(11);
public static YueHui getYue(int numOfGirl) {
return yueHui;
}
public String show() {
return yueHui + ",已约 " + numOfGirl + " 号女朋友";
}
}
- 构造器是私有的，女朋友们不能随意新建约会对象。
- 含有一个静态变量yueHui，在类初始化时，就赋值和11号女朋友约会。
- 有一个静态方法getYue，它是public公共的，提供给别的女生来预约，然而每次都返回已经和11号女友的约会。
- 提供show方法，可以让人知道当前富二代的约会状况。
- 类初始化时就新建了一个对象，可保证单例，并且不存在多线程安全问题。
你听说小菜为了这个程序还特意用上了设计模式，十分激动。
你刚想拍手叫好，突然发现，在约会类初始化的时候，就直接约了11号女朋友。
这完全不符合你被跪舔，被前拥后簇的形象。
不过，你还是微(fèn)笑(nù)地询问了小菜，这是什么单例模式。
耿直的小菜说是饿汉模式。
这下你是真忍不了了，怎么可以使用如此low的名字，这怎么在你的二代朋友们面前装逼。
你准备把这位程序员杀了祭天。
小菜吓得立马动手改代码，一顿修改之后：
public class YueHui {
private int numOfGirl;
private YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
private static YueHui yueHui;
public static YueHui getYue(int numOfGirl) {
if (yueHui == null) {
yueHui = new YueHui(numOfGirl);
}
return yueHui;
}
public String show() {
return yueHui + ",已约 " + numOfGirl + " 号女朋友";
}
}
- 修改后的模式称为懒汉模式。
- 在类加载时不新建对象。
- 每次请求getYue时，先检查静态属性yueHui是否为空，如果为空，就新建一个约会对象，和当前发起约会请求的女朋友进行约会，否者，直接告诉对方已经有约，返回当前的yueHui对象。
为了展示效果，小菜还写了测试代码，用多线程来模拟多个女朋友。
多线程竟然还能用在这个地方，小菜一声长叹，三声叫，汪汪汪。
public class TestYue {
public static void main(String[] args) {
for (int i = 1; i < 11; i++) {
YueHuiThread yueHuiThread = new YueHuiThread(i);
yueHuiThread.start();
}
}
}
class YueHuiThread extends Thread {
private int numOfGirl;
public YueHuiThread(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
@Override
public void run() {
System.out.println(numOfGirl + " 号女友开始预约,预约现状是" + YueHui.getYue(numOfGirl).show());
}
}
输入/输出：
1 号女友开始预约,预约现状是com.jjs.testsingleton.YueHui@682ccf8c,已约 11 号女朋友
3 号女友开始预约,预约现状是com.jjs.testsingleton.YueHui@682ccf8c,已约 11 号女朋友
4 号女友开始预约,预约现状是com.jjs.testsingleton.YueHui@682ccf8c,已约 11 号女朋友
…………
运行了几次，都没问题，每次输出都显示约的是同一个女朋友。
不过这次小菜学乖了，他想到你的女朋友这么多，会不会有成千上百个女友同时发起约会请求呢。
于是，小菜在getYue方法中模拟了线程休眠100毫秒。
public static YueHui getYue(int numOfGirl) {
if (yueHui == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
yueHui = new YueHui(numOfGirl);
}
return yueHui;
}
果然，在运行测试代码时，每次出来的女朋友都不一样。
小菜顿时方了，这不是传说中的多线程安全问题吗，这得把高富帅给累翻在床。
虽然改成了优雅的懒汉模式，但引入了多线程问题。
于是，小菜请教了隔壁老司机老王。
七夕节，隔壁男主人早早回家了，老王正闲着没事干，他建议小菜试试synchronized关键字。
小菜立马改完，在getYue中加入synchronized关键字，并运行测试程序，一切正常。
public class YueHui {
private int numOfGirl;
private YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
private static YueHui yueHui;
public static YueHui getYue(int numOfGirl) {
synchronized (YueHui.class) {
if (yueHui == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
yueHui = new YueHui(numOfGirl);
}
return yueHui;
}
}
public String show() {
return yueHui + ",已约 " + numOfGirl + " 号女朋友";
}
}
然而，在所有女友发起约会请求时，都需要用synchronized进行同步，即排队。
即使是已经确定了约会对象之后，女朋友们还是需要排队来询问，并且需要挨个告诉她们高富帅已经有约了。
是否可以做到，在确定约会对象后，女朋友们可以同时发起请求，并直接告诉她们，你已经有约了。
老王拿过小菜的键盘，就是一顿敲。
public class YueHui {
private int numOfGirl;
private YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
private static YueHui yueHui;
public static YueHui getYue(int numOfGirl) {
if (yueHui == null) {
synchronized (YueHui.class) {
if (yueHui == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
yueHui = new YueHui(numOfGirl);
}
}
}
return yueHui;
}
public String show() {
return yueHui + ",已约 " + numOfGirl + " 号女朋友";
}
}
- 不得不佩服老王的安全意识，在进synchronized代码判断之前，先判断了yueHui对象是否为空，为空则直接返回已有的约会对象。
- 这种操作称为双重检查。
小菜惊讶于还有这种操作，不得不佩服老王还是有一套。
这时候，隔壁小李觉得可以将这个约会程序改的更优雅一些，并提醒小菜，可以用静态内部类来实现。
小菜听到了一个不懂的名词，但又不好意思说自己不会。
毕竟也是陪伴在富二代身边很久的人了，用了一些套路，就让小李帮忙把代码给敲了。
public class YueHui {
private int numOfGirl;
private YueHui(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
private static class YourHeart {
private static YueHui yueHui = new YueHui(11);
}
private static YueHui yueHui;
public static YueHui getYue(int numOfGirl) {
return YourHeart.yueHui;
}
public String show() {
return YourHeart.yueHui + ",已约 " + numOfGirl + " 号女朋友";
}
}
- 加入了静态内部类YourHeart，包含静态对象为和11号女朋友约会。
- 静态内部类在YueHui类加载的时候，不会加载，只会在调用到getYue时返回YourHeart.yueHui时才会被加载。
- 类加载过程多线程安全。在不引入synchronized的情况下，又能实现懒加载。
然而，这种写法，无论有多少女朋友发起约会请求，返回的总是11号女朋友。模式虽好，但不符合富二代的需求。
于是，小菜决定把使用双重检测的懒汉模式约会程序给你看。
然而，小菜发现，你已经迫不及待地使用了第一版的饿汉模式，和11号女朋友开始了优雅的约会(papapa)。
小菜一脸懵X。
更让人意想不到的是，在和11号女朋友一番成长之后，你决定和她结婚，再也不希望别的女朋友们提出约会请求了。
于是，小菜把约会类改成了枚举类，并且只有11号女朋友MARY这个对象。
public enum YueHuiV2 {
MARY(11);
private int numOfGirl;
YueHuiV2(int numOfGirl) {
this.numOfGirl = numOfGirl;
}
}
- 枚举类和普通类唯一不同点在于枚举类加载时，直接新建了申明的对象，即MARY，并且再也不能新建对象。
- 类加载时就新建对象，不存在多线程安全问题。
- 代码很简单，可靠。
终于，小菜把这个约会程序撸完了。
看到作为富二代的你准备收心了，小菜很是高兴。
毕竟从概率上来讲，你少了这么多女朋友，他找到女朋友的概率是变大了。
想想还是挺开心的呢。
这时，小菜看了看时间，七夕马上就要过去了，总算过去了。
三：再理解
- 单例模式的实现方式包括饿汉模式，懒汉模式，双重检查，静态内部类和枚举类等。
- 单例模式在Spring中很常见，Spring的bean一般都为单例，Spring在初始化时将它们保存在一个map中。
- Java程序员很幸福，很少需要自己动手写单例模式。
