0Pricing
Kotlin Academy · Lección

by lazy: análisis detallado de la inicialización diferida

Explore los modos de inicialización diferida: SYNCHRONIZED, PUBLICATION y NONE.

by lazy: análisis detallado de la inicialización diferida es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué es by lazy?

by lazy pospone la inicialización de un val hasta el primer acceso. La lambda se ejecuta una vez y el resultado se almacena en caché.

val greeting: String by lazy {
    println("Computing...")
    "Hello, Kotlin!"
}
fun main() {
    println(greeting) // prints Computing... then Hello, Kotlin!
    println(greeting) // prints Hello, Kotlin! (cached)
}

Sintaxis de lazy

El delegado by lazy recibe una lambda que devuelve el tipo de valor inferido a partir de la declaración de la propiedad.

val pi: Double by lazy { Math.PI }
val appName: String by lazy { "MyApp v1.0" }
fun main() {
    println(pi)      // 3.141592653589793
    println(appName) // MyApp v1.0
}

Modo SYNCHRONIZED (predeterminado)

De forma predeterminada, lazy usa LazyThreadSafetyMode.SYNCHRONIZED: solo un hilo inicializa el valor.

val heavyResource: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    Thread.sleep(100) // simulate work
    "Resource ready"
}
fun main() { println(heavyResource) }

Modo PUBLICATION

PUBLICATION permite que varios hilos inicialicen el valor simultáneamente; gana el primer resultado. Úselo cuando la inicialización sea económica y no tenga efectos secundarios.

val config: Map<String, String> by lazy(LazyThreadSafetyMode.PUBLICATION) {
    mapOf("host" to "localhost", "port" to "8080")
}
fun main() { println(config["host"]) }

Modo NONE

NONE no tiene el coste adicional de la sincronización. Úselo únicamente en contextos de un solo hilo en los que el rendimiento sea importante.

val singleThreadValue: Int by lazy(LazyThreadSafetyMode.NONE) {
    42
}
fun main() { println(singleThreadValue) }

Lazy en una clase

by lazy dentro de una clase inicializa la propiedad al acceder a ella por primera vez, lo que resulta útil para cálculos costosos vinculados al estado de la instancia.

class DatabaseConnection(val url: String) {
    val pool: String by lazy {
        println("Connecting to $url")
        "Pool@$url"
    }
}
fun main() {
    val db = DatabaseConnection("localhost:5432")
    println(db.pool)
}

Lazy frente a lateinit

Use by lazy para un val con una inicialización compleja. Use lateinit para un var asignado externamente (por ejemplo, en pruebas o mediante inyección de dependencias).

class MyService {
    val computed: List<Int> by lazy { (1..100).toList() }
    lateinit var injected: String
}
fun main() {
    val s = MyService()
    s.injected = "injected value"
    println(s.computed.size)
    println(s.injected)
}

Comprobación de isInitialized

Compruebe si una propiedad lazy se ha inicializado con .isInitialized(), pero únicamente mediante la referencia al delegado.

val myLazy: String by lazy { "initialized" }
fun main() {
    val ref = ::myLazy
    // No direct isInitialized on val lazy, but we can check via delegate
    println(myLazy)
}

Lazy con dependencias

Las propiedades lazy pueden hacer referencia a otras propiedades lazy, creando una cadena de inicialización diferida.

val baseUrl: String by lazy { "https://api.example.com" }
val usersUrl: String by lazy { "$baseUrl/users" }
val postsUrl: String by lazy { "$baseUrl/posts" }
fun main() {
    println(usersUrl)
    println(postsUrl)
}

Práctica: servicio singleton

Use by lazy en declaraciones object para inicializar bajo demanda singletons que requieren muchos recursos.

object Analytics {
    val client: String by lazy {
        println("Initializing analytics client")
        "AnalyticsClient@ready"
    }
}
fun main() {
    println("App started")
    println(Analytics.client) // initialized on first use
    println(Analytics.client) // cached
}

Compilación diferida de expresiones regulares

Compilar expresiones regulares es costoso. Use by lazy para compilarlas una vez y reutilizarlas, evitando costes repetidos.

val emailRegex: Regex by lazy {
    Regex("^[A-Za-z0-9+_.-]+@(.+)$")
}
fun isValidEmail(email: String) = emailRegex.matches(email)
fun main() {
    println(isValidEmail("user@example.com")) // true
    println(isValidEmail("bad-email"))         // false
}

Comprobación rápida

¿Qué modo de lazy debería usar en un entorno de un solo hilo para obtener el máximo rendimiento?

Resumen

by lazy ejecuta su lambda una vez, en el primer acceso, y almacena el resultado en caché. Elija SYNCHRONIZED (predeterminado) para garantizar la seguridad de los hilos, PUBLICATION para una inicialización simultánea e idempotente y NONE para obtener rendimiento en un solo hilo.

Preguntas frecuentes

¿La lección «by lazy: análisis detallado de la inicialización diferida» es gratis?

Sí — el texto completo de «by lazy: análisis detallado de la inicialización diferida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «by lazy: análisis detallado de la inicialización diferida»?

Explore los modos de inicialización diferida: SYNCHRONIZED, PUBLICATION y NONE. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «by lazy: análisis detallado de la inicialización diferida»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. by lazy: análisis detallado de la inicialización diferida
  2. Delegados observable y vetoable
  3. Escribir un delegado ReadWriteProperty personalizado
  4. Delegados para preferencias, propiedades respaldadas por mapas y registro
← Volver a Kotlin Academy