What is the this-escaping problem?

• This escape – a reference to the object becomes visible to another thread before the constructor finishes.
• Causes – registering this as a listener, starting a thread from the constructor, passing this to external code.
• Danger – other threads see default field values (null, 0) or partially written final fields.
• JMM rule – safe publication is guaranteed only for fully and correctly constructed objects.
• Fix – private constructor plus static factory method, or @PostConstruct for Spring beans.

How does this escape through listener registration?

When you register this as a listener inside a constructor, the listener callback can be invoked by another thread before the constructor finishes initializing all fields.

package com.bank.monitor;

import java.math.BigDecimal;

// WRONG: this escapes during construction
public class SettlementMonitor {
    private final String bankName;
    private final BigDecimal threshold;

    public SettlementMonitor(EventSource source) {
        source.registerListener(this);  // THIS ESCAPES!
        // Another thread can now call back into this object
        this.bankName = "National Bank of India";
        this.threshold = new BigDecimal("100000");
        // The callback thread may see bankName=null, threshold=null
    }
}

How does this escape through thread start?

Starting a thread from a constructor passes this (via a method reference or inner class) to the new thread. The new thread can begin executing before the constructor finishes.

// WRONG: thread can run before constructor finishes
public class Worker {
    private final int batchSize;

    public Worker() {
        new Thread(this::process).start();  // THIS ESCAPES via method reference!
        this.batchSize = 100;
        // The thread may read batchSize as 0 (default value) instead of 100
    }

    private void process() {
        System.out.println("Batch size: " + batchSize);  // may print 0!
    }
}

How does this escape through inner class capture?

An anonymous inner class or lambda capturing this also publishes the reference to any thread that receives the inner class instance.

// WRONG: this leaks via inner class capture
public class AccountService {
    private final BigDecimal minBalance;

    public AccountService(Executor executor) {
        this.minBalance = new BigDecimal("1000");
        executor.execute(new Runnable() {
            public void run() {
                // Inner class captures enclosing AccountService.this
                System.out.println(AccountService.this.minBalance);
                // May see null if constructor has not finished
            }
        });
    }
}

How do you fix it with a static factory?

The fix is a private constructor plus a public static factory method. The factory first constructs the object completely, then registers it.

package com.bank.monitor;

import java.math.BigDecimal;

public class SettlementMonitor {
    private final String bankName;
    private final BigDecimal threshold;

    private SettlementMonitor() {
        this.bankName = "National Bank of India";
        this.threshold = new BigDecimal("100000");
        // Construction is complete before any external code sees this
    }

    public static SettlementMonitor create(EventSource source) {
        SettlementMonitor monitor = new SettlementMonitor();  // fully built
        source.registerListener(monitor);  // safe: all fields initialized
        return monitor;
    }
}

How do you fix it in Spring?

Spring beans are constructed first, then @Autowired fields are injected, and finally @PostConstruct methods run. Registering listeners in @PostConstruct is safe because the bean is fully initialized.

@Component
public class SettlementMonitor {

    private final String bankName = "National Bank of India";
    private final BigDecimal threshold = new BigDecimal("100000");

    @Autowired
    private EventSource source;

    @PostConstruct
    public void init() {
        source.registerListener(this);  // safe: bean is fully constructed
    }
}

How do final field semantics relate to this escape?

The Java Memory Model guarantees that final fields are visible to other threads after the constructor completes. But if this escapes during construction, other threads can see the object before the constructor finishes, and the final field guarantee does not hold. The JMM explicitly states that this guarantee applies only to properly constructed objects.

What fields are visible during this escape?

| Field type | Visible value during escape |
|------------|----------------------------|
| int, long, double | 0 (default) |
| boolean | false |
| Object references | null |
| final fields | Possibly default (JMM guarantee broken) |

What are common mistakes?

Passing this to any external code during construction. This includes registering listeners, starting threads, publishing to static maps, or calling overridable methods (which may be overridden in a subclass whose constructor has not yet run).

What are common interview follow-up questions?

• Can an object be safely published if it escapes during construction? No. The JMM only guarantees safe publication for fully and correctly constructed objects.
• How does the JMM treat an object whose this escaped? Other threads may observe a partially initialized state with default field values.
• Does calling an overridable method in the constructor count as this escape? Yes, because a subclass override may pass this to external code or access subclass fields that are not yet initialized.