What is lazy loading?

Lazy loading is a design pattern in which the initialization of an object or resource is deferred until it is actually needed. This helps save resources (memory, CPU time) and improve performance, especially when working with large volumes of data or complex objects.

In Java, lazy loading is often used in database interactions (e.g., in ORM frameworks like Hibernate), when loading images, configuring applications, etc.

Implementation methods:

1. Lazy Initialization of Object Field: The most common method. The field is declared but initialized only upon first access.

   // Example of singleton lazy initialization
   public class Singleton {
       private static Singleton instance;
   
       private Singleton() {
           // Private constructor
       }
   
       public static Singleton getInstance() {
           if (instance == null) { // Check if the object is initialized
               instance = new Singleton(); // Initialize on first access
           }
           return instance;
       }
   }
   

2. Proxy Object: A surrogate object is created that intercepts calls to the real object and initializes it upon the first method call.

   // Example of a proxy for lazy loading (simplified)
   interface Resource {
       void load();
   }
   
   class RealResource implements Resource {
       public RealResource() {
           System.out.println("Real resource loaded"); // Long operation
       }
   
       @Override
       public void load() {
           System.out.println("Resource used");
       }
   }
   
   class LazyResourceProxy implements Resource {
       private RealResource realResource;
   
       @Override
       public void load() {
           if (realResource == null) { // Initialize only when used
               realResource = new RealResource();
           }
           realResource.load();
       }
   }
   

3. Virtual Proxy: Similar to a regular proxy but often used in GUI for resource-intensive objects (e.g., images). The proxy displays a placeholder, and the real object loads in the background.

4. Ghost: The object is loaded in a "ghost" state containing only an identifier. Full data is loaded upon first access to any property except the identifier.

5. Collections with Lazy Loading: Used for collections. Instead of loading the entire collection immediately, only a list of identifiers is loaded, and actual elements are loaded as accessed.

Advantages of lazy loading:

• Resource savings (memory, CPU).
• Improved startup performance or when working with large data.
• Simplifies logic in some cases.

Disadvantages of lazy loading:

• Delay on first access to the lazily loaded resource.
• Can complicate debugging due to implicit initialization.
• Issues with concurrent access when implemented without synchronization.

When used in a multithreaded environment, careful implementation is required to ensure thread safety, for example, using Double-Checked Locking or the volatile keyword (Java 5+).