构造函数调用可覆盖方法（延迟调用）

Question

I understand this warning in the normal case like:

class Test {
  public Test() {
    hello();
  }
  public void hello() {}
}

but what if we have something like:

class Test {
  public Test() { 
    // Put the call on a queue that will be executed later
    queue.submit( new Runnable() { 
      public void run() {
        hello();
      }
    });
  }
  public void hello() {}
}

where the call to hello() will not happen immediately. Is this still bad/risky even in the case where the callback executes long after the subclass is ready constructed ?

Answer 1

Is this still bad/risky even in the case where the callback executes long after the subclass is ready constructed

Yes, its still risky. Constructor invocation is not atomic, so deferring the invocation of an instance method from the constructor is no less safe if you do it in another thread, since you have no guarantee that the object will be fully constructed when the thread is (eventually) invoked.

Now, hypothetically , if the subclass object is fully constructed (emphasis on if), then yes, the future callback will be safe. In other words, its not passing around the partially constructed object that is dangerous so much as its accessing it.

Answer 2

I would say yes it is risky just because you are exposing the Test object to a second thread before it is fully constructed.

If you need to control the initialization of Test instances by insuring hello is called, consider using a factory method for instantiation. Combine that with a private constructor and you can guarantee hello is safely called on all Test objects:

public Test {
    /**
     * Factory method to create Test instances and safely call public method
     */
    public static Test getInstance() {
        Test test = new Test();
        test.hello();
        return test;
    }

    /**
     * Private constructor to control Test object creation.
     */
    private Test() {
      super();
    }

    public void hello() {
    }
}