What is escape analysis, and how does it enable the JIT compiler to perform stack allocation or scalar replacement for objects that don't actually need heap allocation, reducing GC pressure?

Escape analysis is a JIT compiler optimization that determines whether an object's reference ever 'escapes' the scope of the method that created it (is it ever stored in a field, passed to another method that might retain it, or returned) -- if the JIT proves an object provably never escapes (used only locally, entirely within the creating method, and never referenced afterward), it can apply scalar replacement (decomposing the object into its individual primitive field values, allocated directly on the stack or even kept in CPU registers, entirely avoiding heap allocation and therefore GC involvement altogether) rather than the more conservative default of always heap-allocating every object, meaningfully reducing GC pressure for code with many short-lived, non-escaping temporary objects (a common pattern in tight computational loops).

public double distance(double x1, double y1, double x2, double y2) {
    // If Point never escapes this method, the JIT's escape analysis can eliminate
    // the heap allocation entirely via scalar replacement, treating x/y as plain local variables
    Point p1 = new Point(x1, y1);
    Point p2 = new Point(x2, y2);
    return p1.distanceTo(p2);
}
// Despite 'new Point(...)' appearing in the source, the JIT may never actually heap-allocate it at runtime