1_基础知识_chapter03_对象的共享_2_发布与逸出

• 发布: 使一个对象能够在当前作用域之外的代码中使用

  逸出: 某个不应该发布的对象被发布

• (1) 发布对象最简单的方式是将对象的引用保存在一个public static变量中, 这样任何类和线程都能看见该对象

  (2) 发布某个对象时, 可能会间接发布其他对象

  例如, 一个容器中装着很多个引用类型,这些引用类型的对象都会被发布

  (3) 发布一个对象时, 在该对象的非private的引用的所有对象都会被发布

  例如

     class Point {
  
         public Integer x;
         public Integer y;
     }
  
     class Line {
  
         private Point pointA;
         private Point pointB;
  
         public Point getPointA() {
  
             return this.pointA;
         }
     }
  

  当调用line.getPointA()时, 不光line对象的pointA对象会被发布, 由于Point类中的x和y都不是private的,所以pointA.x和pointB.y两个Integer对象也会被发布

  (3) 当把一个对象传递给某个外部方法时, 就相当于发布了这个对象

  外部方法: 对于某个类C, 外部方法指的是其他类中定义的方法 + 当前类中可以被改写的方法(既不是private也不是final的方法)

  (4) 最后一种发布对象的机制是发布一个内部的类实例

  因为内部类自动持有外部类的this引用(包括了内部嵌套了几层的内部类也会持有最外部类的this引用)

• 不要在构造过程中使得this引用逸出!!!

  (1) 当从对象的构造函数中发布对象时, 只是发布了一个尚未构造完成的对象, 即使发布对象的语句位于构造函数的最后一行(因为还有指令重排序的问题)

  错误示例

    class EventSource {
  
        private EventListener eventListener;
  
        void registerListener(EventListener eventListener) {
            this.eventListener = eventListener;
        }
  
        public void onEvent(Event e) {
  
            while (this.eventListener == null) {
                Thread.yield();
            }
  
            this.eventListener.onEvent(e);
        }
    }
  
    interface EventListener {
        void onEvent(Event e);
    }
  
    interface Event {
    }
  
  
    class EventSourceThread implements Runnable {
  
        private EventSource eventSource;
  
        public EventSourceThread(EventSource eventSource) {
  
            this.eventSource = eventSource;
        }
  
        @Override
        public void run() {
  
            eventSource.onEvent(new Event() {
            });
        }
    }
  
    public class ThisEscape {
  
        private final int id;
        private final String name;
  
        public ThisEscape(EventSource source) {
  
            this.id = 1;
  
            source.registerListener(new EventListener() {
  
                public void onEvent(Event e) {
  
                    doSomething(e);
  
                    System.out.println(ThisEscape.this.id);
                    System.out.println(ThisEscape.this.name);
                }
            });
  
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
  
            this.name = "ThisEscape";
  
            System.out.println("ThisEscape object's initialization completed!");
        }
  
        private void doSomething(Event e) {
        }
    }
  
    class Test {
  
        public static void main(String[] args) {
  
            EventSource eventSource = new EventSource();
  
            Thread thread = new Thread(new EventSourceThread(eventSource));
            thread.start();
  
            ThisEscape thisEscape = new ThisEscape(eventSource);
        }
    }
  

  输出的结果是

    1
    null
    ThisEscape object's initialization completed!
  

  原因是现在有两个线程: 主线程和EventSourceThread线程, EventSourceThread线程等待着ThisEscape的实例构造, 由于使用了内部类天然获得了外部类的this引用, 所以ThisEscape对象并未完成构造函数, 就已经注册到了eventSource对象里面，EventSourceThread线程就可以执行onEvent()方法。而由于ThisEscape只构造了一半, 所以输出了正确的id和不正确的name(事实上由于指令重排序,id也有可能不正确)。这就造成了this引用逸出

  (2) 另一种常见this引用逸出的情形是在构造函数中启动新线程。即构造函数中创建新线程，新线程已经可以看到this引用, 在未完全构造之前, this引用已经在新线程中启动使用了.

  (3) 这类问题的引发条件是

  1° 使用了内部类

  2° 在构造函数中就把这个内部类给发布了出去

  解决办法就是不要在构造函数中将内部类发布出去。对于(1)中的错误类型,可以使用private构造函数将函数构造完整后，再注册，再使用一个public static的工厂方法获得实例对象; (2)线程在构造函数中的情况，解决思路类似，就是可以在构造函数中将新线程和对象耦合，但是t.start()放在构造函数外面

  正确示例

    interface EventSource {
        void registerListener(EventListener e);
    }
  
    interface EventListener {
        void onEvent(Event e);
    }
  
    interface Event {
    }
  
    public class SafeListener {
  
        private final EventListener listener;
  
        private SafeListener() {
  
            listener = new EventListener() {
                public void onEvent(Event e) {
                    doSomething(e);
                }
            };
        }
  
        public static SafeListener newInstance(EventSource source) {
    
            // 先完整构造        
            SafeListener safe = new SafeListener();
    
            // 再注册耦合
            source.registerListener(safe.listener);
  
            // 返回完整实例对象
            return safe;
        }
  
        private void doSomething(Event e) {
        }
    }
  

• 对于服务器应用程序，无论开发阶段还是测试阶段，都应该加上 -server参数深度优化，因为server深度优化指令重排序优化会更多更明显，这样在开发过程中就会出现问题，而不是运行发布后才出现