/**
* 懒汉式
* 实例在用到的时候才去创建,用的时候才去检查有没有实例,如果有则返回,没有则新建。有线程安全和线程不安全两种写法,区别就是synchronized关键字
*/
public class LazyMode {
private static LazyMode lazyMode;
private LazyMode() {
}
public static synchronized LazyMode getLazyModeInstance() {
if (lazyMode == null) {
lazyMode = new LazyMode();
}
return lazyMode;
}
}
/**
* 饿汉式
* 实例在初始化的时候就已经建好了,不管有没有用到先建好了再说。好处是没有线程安全的问题,坏处是浪费内存空间。
*/
public class HungryMode {
private static HungryMode mode = new HungryMode();
private HungryMode() {
}
public static HungryMode getHungryModeInstance() {
return mode;
}
}
/**
* 双重检查锁
* 结合懒汉式和饿汉式两者的优缺点,特点是在synchronized关键字内外都加了一层if条件判断,这样既保证了线程安全,又比直接上锁提高了执行效率,还节省了内存空间。
*
* 问题1: 为什么两次判空
* 第一个判断避免了不必要的同步,减少性能开销
* 第二个判空避免生成多个对象实例
*
* 比如三个线程A,B,C,假设线程A和线程B同时调用getSingleton()时,判断第一层if判断都为空,这时线程A先拿到锁,线程B在代码块外层等待。
* 线程A进行第二层if判断,new了一个新对象,创建完成释放锁,线程B拿到锁,进行第二层if判断,singleton不为空,直接返回singleton释放锁,避免生成多个对象实例。
* 线程线C调用getSingleton时第一层判断不成立,直接拿到singleton对象返回,避免进入锁,减少性能开销。
*
* 问题2:为什么要用volatile关键字
* 如果不用volatile,并发情况下会出现问题,线程A进入new TestInstance() 的时候,分为:1.分配内存、2.初始化对象、3.mInstance指向内存 三步,
* 此时若发生指令重排,执行顺序是132,执行到第3的时候,线程B刚好进来了,并且执行到注释2,并没有进入synchronized代码块,synchronized修饰的是代码块,不是整个方法。这时候判断mInstance不为空,直接使用一个未初始化的对象会报错。
*/
public class DoubleCheckMode {
private static volatile DoubleCheckMode mode;
private DoubleCheckMode() {
}
public static DoubleCheckMode getDoubleCheckModeInstance() {
if (mode == null) { //2
synchronized (DoubleCheckMode.class) {
if (mode == null) {
mode = new DoubleCheckMode();
}
}
}
return mode;
}
}
/**
* 静态内部类
* 因为内部类是私有的,所以除了get方法外,没有办法访问它,同时static和final是JVM本身的机制保证了线程的安全,同时它在性能上也没有损耗
*/
public class Singleton {
public Singleton() {
}
public static Singleton getInnerStaticMode() {
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
}
/**
* 枚举
* 自动支持序列化机制,绝对防止多次实例化。同时包括静态内部类的优点
*/
public enum EnumSingleton {
INSTANCE;
public void doSomeThing() {
}
}
https://www.jianshu.com/p/f3fae8658f13 如何实现一个线程安全的单例,前提是不能加锁
面试官:说说多线程并发问题 - 掘金 (juejin.cn)