【并发编程-基础】(四)安全发布对象

一、发布与溢出

1.1、发布对象

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

1.2、对象溢出

       一种错误的发布。当一个对象还没有构造完成时，它被其它线程所见。

二、普通的不安全的发布对象

2.1、私有化数组被直接通过get后的返回修改其值

• 下面这个代码通过public访问级别发布了类的域，在类的任何外部的线程都可以访问这些域
• 我们无法保证其他线程会不会修改这个域，从而使私有域内的值错误（下方代码中就对私有域进行了修改）

package com.tangxz._5.publish;

import com.tangxz.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;

/**
 * @Info: 发布对象
 * @Author: 唐小尊
 * @Date: 2019/12/27  10:26
 */
@Slf4j
@NotThreadSafe
public class UnsafePublish {
    private String[] states = {"a","b","c"};
    private String x = "x";

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

    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()));
    }
}
/*输出：11:03:11.274 [main] INFO com.tangxz._5.publish.UnsafePublish - [a, b, c]
11:03:11.279 [main] INFO com.tangxz._5.publish.UnsafePublish - [d, b, c]*/

2.2、this引入溢出

• 在对象完成构造之前不能让它发布，可以避免这种方法
• 这个内部类的实例里面包含了对封装实例的私有域对象的引用，在对象没有被正确构造完成之前就会被发布，有可能有不安全的因素在里面，会导致this引用在构造期间溢出的错误。
• 上述代码在函数构造过程中启动了一个线程。无论是隐式的启动还是显式的启动，都会造成这个this引用的溢出。新线程总会在所属对象构造完毕之前就已经看到它了。
• 因此要在构造函数中创建线程，那么不要启动它，而是应该采用一个专有的start或者初始化的方法统一启动线程
• 这里其实我们可以采用工厂方法和私有构造函数来完成对象创建和监听器的注册等等，这样才可以避免错误
  —————————————————————————————————————————
• 如果不正确的发布对象会导致两种错误：
  （1）发布线程意外的任何线程都可以看到被发布对象的过期的值
  （2）线程看到的被发布线程的引用是最新的，然而被发布对象的状态却是过期的

package com.tangxz._5.publish;

import com.tangxz.annoations.NotRecommend;
import com.tangxz.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

/**
 * @Info: this引入溢出
 * @Author: 唐小尊
 * @Date: 2019/12/27  10:31
 */
@Slf4j
@NotThreadSafe
@NotRecommend
public class Escape {
    private int thisCanBeEscape = 0;
    public Escape(){
        new InnerClass();
    }
    private class InnerClass{
        public InnerClass(){
            //this引入溢出
            //在对象完成构造之前不能让它发布
            log.info("{}",Escape.this.thisCanBeEscape);
        }
    }

    public static void main(String[] args) {
        new Escape();
    }
}
/*输出：11:22:14.381 [main] INFO com.tangxz._5.publish.Escape - 0*/

2.3、单例模式的线程安全

2.3.1、普通懒汉模式（非线程安全）

       单例实例在第一次使用的时候初始化，非线程安全

public class SingletonExample1 {
    //私有构造函数
    private SingletonExample1(){
    }
    //单例对象
    private static SingletonExample1 instance = null;
    //静态的工厂方法获取一个单例对象
    //多线程会出现问题，getInstance方法 + synchronized之后就变得安全了，但是会变得慢
    public static SingletonExample1 getInstance(){
        if (instance==null){
            instance = new SingletonExample1();
        }
        return instance;
    }
}

2.3.2、普通饿汉模式（线程安全）

       单例实例在类装载的时候创建，线程安全

public class SingletonExample2 {
    //私有构造函数
    private SingletonExample2() {
    }
    //单例对象
    private static SingletonExample2 instance = new SingletonExample2();
    
    public static SingletonExample2 getInstance() {
        return instance;
    }
}

2.3.3、懒汉模式（非线程安全）（双重同步锁实现）

       还没执行完初始化过程，就直接返回，因为当执行到2的时候就已经有了对象，对象就不为空

public class SingletonExample3 {
    //私有构造函数
    private SingletonExample3() {
    }
    //1、memory = allocate() 分配对象内存空间
    //2、ctorInstance() 初始化对象
    //3、instance = memory 设置instance指向刚分配的内存
    //可能会出现指令重排的情况

    //JVM和CPU优化，发生了指令重排
    //1、memory = allocate() 分配对象内存空间
    //3、instance = memory 设置instance指向刚分配的内存
    //2、ctorInstance() 初始化对象

    //还没执行完初始化过程，就直接返回，因为当执行到2的时候就已经有了对象，对象就不为空
    //单例对象
    private static SingletonExample3 instance = null;
    //静态的工厂方法获取一个单例对象
    public static SingletonExample3 getInstance() {
        if (instance == null) {//双重检测机制          // B
            synchronized (SingletonExample2.class) {   //同步锁
                if (instance == null) {
                    instance = new SingletonExample3();// A - 3
                }
            }
        }
        return instance;
    }

2.3.4、懒汉模式（线程安全）volatile+双重检测机制

       懒汉模式，volatile+双重检测机制禁止指令重排

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

    //单例对象  volatile+双重检测机制->不会发生指令重排
    private static volatile SingletonExample5 instance = null;

    //静态的工厂方法获取一个单例对象
    public static SingletonExample5 getInstance() {
        if (instance == null) {//双重检测机制          // B
            synchronized (SingletonExample2.class) {   //同步锁
                if (instance == null) {
                    instance = new SingletonExample5();// A - 3
                }
            }
        }
        return instance;
    }
}

2.3.5、静态域和静态代码块的执行顺序

       静态域和静态代码块的执行顺序是根据在文档中的位置来的。静态域和静态代码块的执行顺序是根据在Java文件中，从上至下出现的顺序执行的

//私有构造函数
    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());
    }

2.3.6、枚举模式实现单例模式（安全高效）

package com.tangxz._5.singleton;

import com.tangxz.annoations.Recommend;
import com.tangxz.annoations.ThreadSafe;

/**
 * @Info: 枚举实现实例化最安全，枚举模式最安全
 * @Author: 唐小尊
 * @Date: 2019/12/27  10:38
 */
@ThreadSafe
@Recommend
public class SingletonExample7 {
    //私有构造函数
    private SingletonExample7() {

    }
    public static SingletonExample7 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }
    private enum  Singleton{
        INSTANCE;
        private SingletonExample7 singleton;
        //JVM保证这个方法绝对只调用一次
        Singleton(){
            singleton = new SingletonExample7();
        }
        public SingletonExample7 getInstance(){
            return singleton;
        }
    }
    public static void main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

三、安全的发布对象

3.1、安全的发布对象

• 静态初始化函数中初始化一个对象引用
• 将对象的应用保存到volatile类型域或者AtomicReference对象中
• 将对象的引用保存到某个正确构造对象的final类型域中
• 将对象的引用保存到一个由锁保护的域中

3.2、安全的代码规范以及操作

• 代理模式的懒汉模式使用volatile+双重检测机制实现禁止指令重排。防止多线程单例模式下，可能会出现对象刚被赋予内存空间就被直接返回。
• 静态域和静态代码块的执行顺序是根据在文档中的位置来的
• 枚举模式来实现单例模式是最安全的