吃透设计模式之单例模式
提到单例模式,那可谓是家喻户晓,可以说这个模式是设计模式最常见之一。说到单例模式,那不得不提懒汉式和饿汉式两种方式。相信知道单例模式的人对这两种模式也是比较熟悉的,看到这里你还以为我就是讲讲这两种模式吗?那肯定不是,既然来了,就给你多讲解几种。
那就先从懒汉式和饿汉式开始吧。
饿汉式
package 设计模式.单例模式;
public class 饿汉式 {
private static final 饿汉式 instance = new 饿汉式();
private 饿汉式() {}
public static 饿汉式 getInstance() {
return instance;
}
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(饿汉式.getInstance().hashCode());
}).start();
}
}
}
问题1:问题来了,你知道它为什么叫饿汉式吗?有什么缺点吗?
懒汉式
package 设计模式.单例模式;
public class 懒汉式 {
private static 懒汉式 instance;
private 懒汉式() {}
public static 懒汉式 getInstance() {
if (instance == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
instance = new 懒汉式();
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(懒汉式.getInstance().hashCode());
}).start();
}
}
}
问题2:问题又来了,你知道它为什么叫懒汉式吗?有什么缺点吗?
懒汉式优化
package 设计模式.单例模式;
public class 懒汉式优化 {
private static 懒汉式优化 instance;
private static final Object lock = new Object();
public static 懒汉式优化 getInstance() {
if (instance == null) {
synchronized (lock) {
if (instance == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
instance = new 懒汉式优化();
}
}
}
return instance;
}
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(懒汉式优化.getInstance().hashCode());
}).start();
}
}
}
问题3:为什么能优化懒汉式?这里做两次判断instance == null是必须的吗?
单例内部类实现
package 设计模式.单例模式;
public class 单例内部类实现 {
private static 单例内部类实现 instance;
private 单例内部类实现() {}
private static class Inner {
private static final 单例内部类实现 instance = new 单例内部类实现();
}
private static 单例内部类实现 getInstance() {
return Inner.instance;
}
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(单例内部类实现.getInstance().hashCode());
}).start();
}
}
}
问题4:为什么用内部类能保证单例?
单例枚举
package 设计模式.单例模式;
public enum 单例枚举 {
INSTANCE;
public static void main(String[] args) throws Exception {
for(int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(单例枚举.INSTANCE.hashCode());
}).start();
}
}
}
问题5:这种方式与之前的方式对比,有什么优点?
现在来回答上面的问题。
- 因为在类加载的时候即初始化类实例,缺点就是类加载即实例化,如果类用不到,类在装载的时候没必要实例化;
- 真正要用的时候才去实例化,虽然这里会判断instance是否为null,但是存在线程不安全的情况;
- 通过加锁的方式,要实例化之前要加锁,以免其他线程同时实例化。加锁前后两次判断instance是否为空,第一次判断是避免频繁加锁,第二次判断是保证多线程不会多次创建实例;
- 外部类加载的时候,内部类不会被加载(懒加载),只有在调用getInstance方法的时候才会别实例化。这里利用jvm的一个特性,就是一个类只会加载一次,因此内部类也只会被进行一次实例化,从而保证了单例;
- 利用枚举的特性,因而只能存在一个实例。非常完美的方式!
到这里,你对单例模式有了个大概了解吧,如果对上面的内容还不理解的,可以拷贝代码运行调试看看结果。后面我们会继续学习其他设计模式。