> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Lazy Delegation Kotlin lazy delegation is a property delegation mechanism that defers the initialization of a read-only (`val`) property or local variable until the exact moment of its first access. Upon the initial invocation, the provided lambda expression executes, computes the result, and caches it within the internal state of a `Lazy` instance. All subsequent accesses bypass the lambda and directly return the cached value. ## Syntax and Mechanics The mechanism is implemented using the `by` keyword combined with the `lazy` standard library function. ```kotlin theme={"dark"} val propertyName: String by lazy { "Computed Value" } ``` Since Kotlin 1.1, lazy delegation is not restricted to class properties; it can also be used for local delegated properties inside functions. This defers the initialization of a local variable until it is evaluated in the execution flow. ```kotlin theme={"dark"} fun processData() { val localVariable: Int by lazy { 42 } // Initialization lambda executes here println(localVariable) } ``` Under the hood, the `lazy` function takes a lambda and returns an instance of the `Lazy` interface. The `by` keyword delegates the getter to the `getValue()` operator. This operator is an extension function provided statically by the Kotlin standard library for the `Lazy` interface, rather than being a member function of the instance itself. Because the standard `Lazy` interface does not provide a `setValue()` operator, lazy delegation is strictly restricted to read-only declarations using `val`. ## Internal State A `Lazy` instance maintains an internal state to track initialization. Before access, the internal value holds a special `UNINITIALIZED_VALUE` token. Once the lambda completes, this token is overwritten with the computed result, and the reference to the initialization lambda is typically nullified to allow garbage collection. ## Thread Safety Modes The `lazy` function accepts an optional `LazyThreadSafetyMode` enum parameter to dictate how the initialization lambda behaves in a multithreaded environment. ### 1. `SYNCHRONIZED` (Default) The initialization is protected by a lock. Only a single thread can execute the lambda and initialize the value. All other threads attempting to access the property will block until the initialization is complete, ensuring a single source of truth. ```kotlin theme={"dark"} val safeProperty: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "Thread-safe initialization" } ``` ### 2. `PUBLICATION` Multiple threads can execute the initialization lambda concurrently if the value is uninitialized. However, the internal state uses an atomic compare-and-set (CAS) operation. The first thread to successfully execute the CAS operation on the internal state will have its result cached within the `Lazy` instance. The results from other concurrent threads are discarded. ```kotlin theme={"dark"} val pubProperty: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "Concurrent execution, single assignment" } ``` ### 3. `NONE` No synchronization locks or atomic operations are used. This mode incurs the lowest performance overhead but is strictly unsafe in multithreaded contexts. If multiple threads access the uninitialized property simultaneously, the lambda may execute multiple times, and the final cached value is undefined. ```kotlin theme={"dark"} val fastProperty: String by lazy(LazyThreadSafetyMode.NONE) { "No synchronization overhead" } ``` ## Custom Locks When using the default `SYNCHRONIZED` mode, the `Lazy` instance uses itself as the synchronization monitor by default. Kotlin allows passing a custom lock object to the `lazy` function to synchronize the initialization against an external monitor. ```kotlin theme={"dark"} val lock = Any() val lockedProperty: String by lazy(lock) { "Synchronized on external lock object" } ```

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More