0Pricing
Kotlin Academy · Aula

by lazy: análise detalhada da inicialização adiada

Explore os modos de inicialização adiada: SYNCHRONIZED, PUBLICATION e NONE.

by lazy: análise detalhada da inicialização adiada é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é by lazy?

by lazy adia a inicialização de um val até o primeiro acesso. A lambda é executada uma vez e o resultado é armazenado em cache.

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

Sintaxe de lazy

O delegado by lazy recebe uma lambda que retorna o tipo de valor inferido a partir da declaração da propriedade.

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 (padrão)

Por padrão, lazy usa LazyThreadSafetyMode.SYNCHRONIZED: apenas uma thread inicializa o valor.

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

Modo PUBLICATION

PUBLICATION permite que várias threads inicializem simultaneamente; o primeiro resultado prevalece. Use-o quando a inicialização for barata e não tiver efeitos colaterais.

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

Modo NONE

NONE não tem sobrecarga de sincronização. Use-o somente em contextos de thread única nos quais o desempenho seja importante.

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

Lazy em uma classe

by lazy dentro de uma classe inicializa o valor no primeiro acesso à propriedade, sendo útil para cálculos dispendiosos ligados ao estado da instância.

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 versus lateinit

Use by lazy para val com inicialização complexa. Use lateinit para var atribuído externamente (por exemplo, em testes ou na injeção de dependências).

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)
}

Verificação de isInitialized

Verifique se uma propriedade lazy foi inicializada com .isInitialized() — mas somente por meio da referência ao 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 com dependência

As propriedades lazy podem fazer referência a outras propriedades lazy, formando um fluxo de inicialização lazy.

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ática: serviço singleton

Use by lazy em declarações object para inicializar singletons pesados sob demanda.

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
}

Compilação lazy de expressões regulares

Compilar expressões regulares é dispendioso. Use by lazy para compilar uma vez e reutilizar, evitando sobrecarga repetida.

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
}

Verificação rápida

Qual modo lazy você deve usar em um ambiente de thread única para obter o máximo desempenho?

Recapitulação

by lazy executa sua lambda uma vez, no primeiro acesso, e armazena o resultado em cache. Escolha SYNCHRONIZED (padrão) para segurança entre threads, PUBLICATION para inicialização idempotente concorrente e NONE para desempenho em thread única.

Perguntas Frequentes

A aula “by lazy: análise detalhada da inicialização adiada” é grátis?

Sim — o texto completo de “by lazy: análise detalhada da inicialização adiada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “by lazy: análise detalhada da inicialização adiada”?

Explore os modos de inicialização adiada: SYNCHRONIZED, PUBLICATION e NONE. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “by lazy: análise detalhada da inicialização adiada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. by lazy: análise detalhada da inicialização adiada
  2. Delegados observable e vetoable
  3. Escrevendo um delegado ReadWriteProperty personalizado
  4. Delegados para preferências, propriedades baseadas em mapas e registro
← Voltar para Kotlin Academy