为什么单例模式要起名叫饿汉式和懒汉式?
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)
- 双重检查
- 静态内部类
- 枚举
1.饿汉式
class Single1 {
// 1. 构造器私有化, 外部能 new
private Single1() {
}
// 2.本类内部创建对象实例
private final static Single1 instance = new Single1();
// 3. 提供一个公有的静态方法,返回实例对象
public static Single1 getInstance() {
return instance;
}
// // 4. 在静态代码块中,创建单例实例, 将步骤2替换
// private final static Single1 instance;
// static {
// instance = new Single1();
// }
}
不管程序是否需要这个对象的实例,总是在类加载的时候就先创建好实例,理解起来就像不管一个人想不想吃东西都把吃的先买好,如同饿怕了一样。
2.懒汉式
(线程不安全)(不推荐使用)
class Single2 {
private Single2() {
}
private static Single2 instance;
// 提供一个静态的公有方法,当使用到该方法时,才去创建 instance
// 即懒汉式
public static Single2 getInstance() {
if (instance == null) {
instance = new Single2();
}
return instance;
}
}
- 起到了 Lazy Loading 的效果,但是只能在单线程下使用。
- 如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
如果一个对象使用频率不高,占用内存还特别大,明显就不合适用饿汉式了,这时就需要一种懒加载的思想,当程序需要这个实例的时候才去创建对象,就如同一个人懒的饿到不行了才去吃东西。
(线程安全,同步代码块)(不推荐使用)
class Single3 {
private static Single3 instance;
private Single3() {
}
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
//即懒汉式
public static synchronized Single3 getInstance() {
if (instance == null) {
instance = new Single3();
}
return instance;
}
}
- 解决了线程安全问题
- 效率太低了,每个线程在想获得类的实例时候,执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接 return 就行了。方法进行同步效率太低 。
(线程安全,同步代码块)(不推荐使用)
class Single4 {
private Single4() {
}
private static Single4 instance;
public static Single4 getInstance() {
if (instance == null) {
synchronized (Single4.class) {
instance = new Single4();
}
}
return instance;
}
}
(双重检查)(推荐使用)
- volatile 是一个类型修饰符。volatile 的作用是作为指令关键字,确保本条指令不会因编译器的优化而省略。
volatile 的特性
- 保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。(实现可见性)
- 禁止进行指令重排序。(实现有序性)
- volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。
class Single5 {
private static volatile Single5 instance;
private Single5() {
}
//提供一个静态的公有方法,加入双重检查代码,解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static synchronized Single5 getInstance() {
if (instance == null) {
synchronized (Single5.class) {
if (instance == null) {
instance = new Single5();
}
}
}
return instance;
}
}
- Double-Check 概念是多线程开发中常使用到的,如代码中所示,我们进行了两次 if (singleton == null)检查,这样就可以保证线程安全了。
- 这样,实例化代码只用执行一次,后面再次访问时,判断 if (singleton == null),直接 return 实例化对象,也避免的反复进行方法同步。
- 线程安全;延迟加载;效率较高。
静态内部类(推荐使用)
class Single6 {
//构造器私有化
private Single6() {}
//写一个静态内部类,该类中有一个静态属性
private static class SingleInstance {
private static final Single6 INSTANCE = new Single6();
}
//提供一个静态的公有方法,直接返回
public static synchronized Single6 getInstance() {
return SingleInstance.INSTANCE;
}
}
JVM底层类装载机制,线程安全。
枚举(推荐使用)
enum Single7 {
INSTANCE; // 属性
public void sayOK() {
System.out.println("ok~");
}
}
- 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
- 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。
终于说完了,涨姿势吧。