Item Use lazy initialization sparingly

What is lazy initialization?

• Definition: Defer initialization of a field until it is accessed for the first time.
• Benefits: Avoids unnecessary initializations if the field is never used.
• Applications: Used for static and instance fields.

Best Practices and Examples

1. Normal Boot (Preferred) Simple and effective.

Example:

private final FieldType field = computeFieldValue();

Use normal initialization for most fields, unless otherwise required.

1. Lazy Initialization with Synchronized Getter When to use: To resolve startup circularities.

Example:

private FieldType field;

synchronized FieldType getField() {
    if (field == null) {
        field = computeFieldValue();
    }
    return field;
}

3. Carrier Class Practice (For Static Fields)

• When to use: Efficient lazy initialization for static fields.

Example:

private static class FieldHolder {
    static final FieldType field = computeFieldValue();
}

static FieldType getField() {
    return FieldHolder.field;
}

Advantage: Initializes the class only when the field is accessed, with minimal cost after initialization.

4. Double Check Practice (For Instance Fields)

• When to use: For performance on lazy initialization on instance fields.

Example:

private volatile FieldType field;

FieldType getField() {
    FieldType result = field;
    if (result == null) { // Primeira verificação (sem bloqueio)
        synchronized (this) {
            result = field;
            if (result == null) { // Segunda verificação (com bloqueio)
                field = result = computeFieldValue();
            }
        }
    }
    return result;
}

5. Single Check Practice (Repeated Initialization Allowed)

• When to use: Fields that can tolerate repeated initialization.

Example

private volatile FieldType field;

FieldType getField() {
    if (field == null) { // Verificação única
        field = computeFieldValue();
    }
    return field;
}

6. Bold Single Check Practice

• When to use: Only if you tolerate extra initializations and if the field type is a primitive other than long or double.

Example:

private FieldType field;

FieldType getField() {
    if (field == null) { // Sem volatile
        field = computeFieldValue();
    }
    return field;
}

General Considerations

Trade-offs:

• Lazy initialization minimizes initial cost but can increase field access cost.
• Evaluate with performance measurements.

Multithread Synchronization:

• Essential to avoid serious bugs.
• Use safe practices (e.g., volatile, locks).

Preferred Use:

• Static Fields: Carrier class practice.
• Instance Fields: Double Check.
• Repeated Startup Allowed: Single check.

Final Summary

• Boot normally whenever possible.
• Use lazy initialization only when necessary for performance or to resolve circularity issues

The above is the detailed content of Item Use lazy initialization sparingly. For more information, please follow other related articles on the PHP Chinese website!