技术成就梦想

并发编程(七):安全发布对象



  什么是发布对象?

  发布对象是指使一个对象能够被当前范围之外的代码所使用

  什么是对象逸出?

  对象逸出是一种错误的发布,指当一个对象还没有构造完成时,就使它被其他线程所见

 

  逸出-demo

@Slf4j
public class Escape {

    private int thisCanBeEscape = 0;

    public Escape() {
        new InnerClass();
    }

    private class InnerClass{
        public InnerClass() {
            log.info("{}", Escape.this.thisCanBeEscape);
        }
    }

    public static void main(String[] args) {
        new Escape();
    }

}

  在此实例中Escape对象还没有构造完成,就访问了该对象的成员变量thisCanBeEscape,该类是线程不安全的,并且非常不推荐这么写。

 

  不安全的发布-demo

@Slf4j
public class UnsafePublish {

    private String[] states = {"a", "b", "c"};

    public String[] getStates() {
        return states;
    }

    public static void main(String[] args) {
        UnsafePublish unsafePublish = new UnsafePublish();
        log.info("{}", Arrays.toString(unsafePublish.getStates()));

        unsafePublish.getStates()[0] = "d";
        log.info("{}", Arrays.toString(unsafePublish.getStates()));

    }
}

  输出为:[a,b,c]和[d,b,c] 这样发布的对象为线程不安全的,因为无法保证其他线程是否会修改states域,从而造成状态错误

 

  安全发布对象的四种方法:

  a、在静态初始化函数中初始化一个对象引用

  b、将对象的引用保存到volatile类型域或AtomicReference对象中

  c、将对象的引用保存到某个正确构造对象的final类型域中

  d、将对象的引用保存到一个由锁保护的域中

 

 如何安全的发布一个对象呢?

 我们以对不同单例的实现,来说明一下安全发布对象的方法

 

  单例-demo1

public class SingletonExample1 {

    //私有构造函数
    private SingletonExample1() {

    }
    //单例对象
    private static SingletonExample1 instance = null;

    //静态的工厂方法
    public static SingletonExample1 getInstance() {

        //单线程没有问题,多线程的时候会出现问题
        if (instance == null) {
            instance = new SingletonExample1();
        }

        return instance;
    }
}

  此实例在单线程模式下没有任何问题,但在多线程模式下,如两个线程都同时运行到判断instance==null时,就有可能new出两个实例来,所以说这是线程不安全的,这也就是懒汉模式,此实例满足了a条件,如果再加上d条件,在判断是否为null时加锁,就可以变为线程安全的

 

  单例-demo2

public class SingletonExample2 {

    //饿汉模式不足,如果构造方法中有过多的处理,会导致类加载的时候特别慢
    //私有构造函数
    private SingletonExample2() {

    }
    //单例对象
    private static SingletonExample2 instance = new SingletonExample2();

    //静态的工厂方法
    public static SingletonExample2 getInstance() {

        return instance;
    }
}

  此demo是线程安全的,使用饿汉模式时需要注意两点,一是此类肯定被使用(避免造成资源浪费),二是私有的构造方法中没有过多的处理4

 

  单例-demo3

public class SingletonExample3 {

    //私有构造函数
    private SingletonExample3() {

    }
    //单例对象
    private static SingletonExample3 instance = null;

    //静态的工厂方法
    public static synchronized SingletonExample3 getInstance() {

        //单线程没有问题,多线程的时候会出现问题
        if (instance == null) {
            instance = new SingletonExample3();
        }

        return instance;
    }
}

  此demo即为demo1加锁的情况,是线程安全的,但是并不推荐这么写,因为这样虽然保证了线程安全,但在性能上有一定的开销

 

  单例-demo4

/**
 * 懒汉模式 双重同步锁单例模式
 * 单例实例在第一次使用时进行创建
 * 双重检测机制不一定线程安全,因为有指令重排的存在
 */
public class SingletonExample4 {

    //私有构造函数
    private SingletonExample4() {

    }


    //单例对象
    private static SingletonExample4 instance = null;

    //静态的工厂方法
    public static  SingletonExample4 getInstance() {

        //单线程没有问题,多线程的时候会出现问题
        if (instance == null) {  //双重检测机制

            //同步锁
            synchronized (SingletonExample4.class) {
                if (instance == null) {
                    instance = new SingletonExample4();
                }
            }

        }

        return instance;
    }

}

    此demo是懒汉模式的优化版本,但注意此demo不是线程安全的,因为有指令重排的存在,当执行instance=new SingletonExample4()时,cpu会执行三步操作:1、memory=allocate() 分配对象的内存空间  2、ctorInstance()初始化对象 3、instance = memory 设置instance指向刚分配的内存, 但是由于jvm和cpu的优化,会发生指令重排,如重排的结果变为1,3,2,在单线程的情况下没有任何问题,但是在多线程的情况下就可能发生问题,如果此时A线程执行到instance=new SingletonExample4(),发生了指令重排,执行到了第二步的3,此时instance已经执行了该对象的内存,但是该对象还没有初始化,如果在此时B线程正好执行到if(instance==null),此时该条件已经不成立,直接return,因为这个对象还没有初始化,直接去使用这个对象就可能发生问题。

 

  单例-demo5

/**
 * 懒汉模式 双重同步锁单例模式
 * 单例实例在第一次使用时进行创建
 * 双重检测机制不一定线程安全,因为有指令重排的存在
 */
public class SingletonExample5 {

    //私有构造函数
    private SingletonExample5() {

    }

    //1、memory = allocate()  分配对象的内存空间
    // 2、 ctorInstance() 初始化对象
    // 3、 instance = memeory 设置instance指向刚分配的内存


    //通过volatile和双重检测机制限制指令重排,volatile限制了代码的写操作
    //单例对象,通过volatile限制代码发生指令重排
    private volatile static SingletonExample5 instance = null;

    //静态的工厂方法
    public static SingletonExample5 getInstance() {

        //单线程没有问题,多线程的时候会出现问题
        if (instance == null) {  //双重检测机制

            //同步锁
            synchronized (SingletonExample5.class) {
                if (instance == null) {
                    instance = new SingletonExample5();
                }
            }

        }

        return instance;
    }
}

  此demo是demo4的升级版,只要解决了指令重排问题,在上篇博客“线程安全性中”我们已经介绍了volatile可以限制代码发生指令重排,此demo是线程安全的。

 

  单例-demo6

/**
 * 饿汉模式
 * 单例实例在类装载时进行创建
 */
@ThreadSafe
public class SingletonExample6 {

    //饿汉模式不足,如果构造方法中有过多的处理,会导致类加载的时候特别慢
    //私有构造函数
    private SingletonExample6() {

    }
    //单例对象   静态域的初始化
    private static SingletonExample6 instance = null;

    //静态块方式
    static {
        instance = new SingletonExample6();
    }
    
    //静态的工厂方法
    public static SingletonExample6 getInstance() {

        return instance;
    }

    public static void main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

  demo2是饿汉模式的静态代码域方式,此demo是饿汉模式的静态代码块方式,此demo也是线程安全的

 

   单例-demo7

/**
 * 枚举模式:最安全
 * 相比于懒汉模式在安全性方面更容易保证
 * 相比于饿汉模式是在实际调用的时候才做最开始的初始化
 */
public class SingletonExample7 {
    
    private SingletonExample7() {

    }
    //静态的工厂方法
    public static SingletonExample7 getInstance() {

        return Singleton.INSTANCE.getSingleton();
    }

    private enum Singleton{
        INSTANCE;
        private SingletonExample7 singleton;

        //JVM保证这个方法绝对只调用一次,且是在这个类调用之前初始化的
        Singleton() {
            singleton = new SingletonExample7();
        }

        public SingletonExample7 getSingleton() {
            return singleton;
        }
    }

}

  此demo是我们最推荐的单例写法,并且是线程安全的,它相比于懒汉模式在安全性方面更容易保证,相比于饿汉模式是在实际调用的时候才做最开始的初始化