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


      什么是发布对象?

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

      什么是对象逸出?

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

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

  • 相关阅读:
    四、系统开发和运行知识(二)
    9.Parameters
    7.Constants and Fields
    四、系统开发和运行知识(一)
    三、操作系统知识(3)
    6.Type and Member Basics
    三、操作系统知识(2)
    5.Primitive, Reference, and Value Types
    4、Type fundamentals
    三、操作系统知识(1)
  • 原文地址:https://www.cnblogs.com/sbrn/p/9003156.html
Copyright © 2020-2023  润新知