多线程Debug窥探单例模式

1. 懒汉式单例模式

通过延迟初始化,降低单例创建期间的资源开销。

懒汉式单例实现,存在线程安全问题

public class LazySingleton {
    private static LazySingleton lazySingleton;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (lazySingleton == null) {  // 断点,suspend:thread
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

线程任务

@Slf4j
public class T implements Runnable {
    @Override
    public void run() {
        LazySingleton instance = LazySingleton.getInstance();
        log.info("{} - {}", Thread.currentThread(), instance);
    }
}

在主线程中创建两个线程任务T,通过IDEA多线程Debug控制线程的执行顺序,使其在控制台输出不同的实例。

private void singleton() {
    Thread t1 = new Thread(new T());
    Thread t2 = new Thread(new T());
    t1.start();
    t2.start();
    log.info("end"); // 断点,suspend:thread
}

备注:IDEA如何实现多线程Debug

断点-右键断点-挂起选择thread模式

1.1. 使用synchronized解决懒汉式线程安全问题

public synchronized static LazySingleton getInstance() {
    if (lazySingleton == null) {
        lazySingleton = new LazySingleton();
    }
    return lazySingleton;
}

这时候在使用多线程Debug,可以发现其中一个线程任务处于阻塞状态。

这种方法性能开销较大。

备注:synchronized锁静态方法相当于锁整个类文件,synchronized锁普通方法相当于锁堆内存中的对象实例。

1.2. 使用double check双重检查解决懒汉式线程安全问题

public class LazyDoubleCheckSingleton {
    private static LazyDoubleCheckSingleton lazyDoubleCheckSingleton;
    private LazyDoubleCheckSingleton() {}
    public static LazyDoubleCheckSingleton getInstance() {
        if (lazyDoubleCheckSingleton == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (lazyDoubleCheckSingleton == null) {
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

存在指令重排序问题,即lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();这行代码实际上执行了三个步骤:

  1. 分配堆内存
  2. 初始化对象(类加载之后,被线程使用之前)
  3. 将栈中的变量指向堆内存

2和3的执行顺序可能颠倒,这就是指令重排序,在单线程环境下这个问题不会影响到程序正常执行,但是在多线程环境下,线程1跳过了步骤2执行了步骤3,这时候线程1挂起,CPU控制权切换到线程2,线程2拿到还没初始化的对象,程序就会抛异常。

解决指令重排序问题:

1)不允许指令重排序。使用volatile

private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton;

通过volatile配合double check双重检查的懒汉式单例模式不仅解决了线程安全问题,而且还兼顾到了性能,这种方式会比直接使用synchronized来得更好点。

2)允许指令重排序,但其它线程不可见,通过静态内部类解决。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}
    private static class InnerClass {
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance() {
        return InnerClass.staticInnerClassSingleton;
    }
}

Class对象的初始化锁,即哪个线程拿到InnerClass对象的初始化锁,哪个对象就去初始化它,而其它线程属于非构造线程,所以即使构造期间出现了指令重排序,那么其它线程也是看不见的。

2. 饿汉式单例模式

使用final static修饰实例对象使类在加载完成之后,完成实例对象的初始化,且不能再修改。

public class HungrySingleton {
    private final static HungrySingleton hungrySingleton;
    static {
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton() {}
    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

这种方法使类加载完成之后就完成实例对象的初始化,若应用里没有使用到这个单例对象就会造成内存资源的浪费。与懒汉式不同,懒汉式是需要使用时才去初始化对象,所以不用考虑资源浪费问题。但是懒汉式存在线程安全问题,而饿汉式则没这种问题,开发者可以根据实际的业务需求选择最恰当的解决方案。

3. 破坏单例模式

序列化反序列化会破坏单例模式:

序列化和反序列化时获取到的是两个不同的实例对象,因为反序列化时,会判断单例类中是否存在readReslove方法,如果有的话会调用这个方法返回单例对象,否则会通过反射机制重新获取一个新的单例对象。

反射攻击也会破坏单例模式。

使用枚举实现单例,1)枚举单例类不受序列化反序列化破坏,2)屏蔽反射攻击

你可能感兴趣的:(多线程Debug窥探单例模式)