Kotlin — Explicación de los modos de seguridad Lazy Thread

May 10 2022
Profundizaremos en los modos de seguridad de subprocesos de la propiedad Lazy y comprenderemos la diferencia entre ellos. La propiedad Kotlin Lazy le permite crear un objeto cuando lo llama por primera vez una vez, luego devuelve el objeto almacenado cada vez que accede a esta variable.

Profundizaremos en los modos de seguridad de subprocesos de la propiedad Lazy y comprenderemos la diferencia entre ellos.

La propiedad Kotlin Lazy le permite crear un objeto cuando lo llama por primera vez una vez, luego devuelve el objeto almacenado cada vez que accede a esta variable.

Al usar la propiedad Lazy obtendrá un mejor rendimiento porque

  1. El objeto se creará solo cuando lo necesite.
    Por ejemplo, es posible que no necesite filteredListsi el usuario no seleccionó la opción de filtro en esa pantalla.
  2. Reutilizará el valor inicializado en lugar de reiniciarlo cada vez que lo necesite. Eso es muy útil cuando tienes objetos pesados ​​como DB o listas enormes.

Seguridad de subprocesos

Nota : si comprende la seguridad de subprocesos, omita esta sección.

Thread-Safe significa que tiene un código predecible que puede ejecutarse en múltiples subprocesos simultáneamente sin ninguna condición de carrera . Una condición de carrera puede ocurrir cuando uno o más subprocesos actualizan un recurso compartido al mismo tiempo. Es difícil entender esta declaración sin un ejemplo, así que echemos un vistazo a un ejemplo :)

Digamos que tenemos una aplicación bancaria…

Digamos que llamamos takePayment()y takeMonthlyFee()en dos hilos diferentes simultáneamente. Eso significa que el orden del código no será predecible. Entonces, consideremos que el código se ejecuta en el siguiente orden.

  1. takePayment(100.0)saldo = 100.0 y cantidad de pago = 100
  2. if (paymentAmount <= balance)será verdadero, saldo = 100.0 y cantidad de pago = 100
  3. takeMonthlyFee()llamado saldo = 100.0 y cantidad de pago = 100
  4. balance -= 10saldo = 90,0 y cantidad de pago = 100
  5. balance -= paymentAmountAquí está el problema….

Necesitamos hacer que nuestras funciones sean seguras para subprocesos. Entonces, la solución generalmente es bloquear el código que usa los recursos compartidos hasta que esté listo y luego liberarlo.

por lo tanto, aunque takeMonthlyFee()se llame después de la instrucción if en nuestro ejemplo anterior, Kotlin hará que espere hasta que finalice nuestro bloque sincronizado . Problema resuelto.

Hay muchas otras soluciones para hacer que su código sea seguro para subprocesos. aquí hay un gran artículo .

Modos de seguridad de subprocesos

De forma predeterminada, la propiedad perezosa usa el modo, pero la propiedad perezosa tiene en realidad 3 modos que puede pasar como parámetro a la función perezosa .LazyThreadSafetyMode.SYNCHRONIZED

  1. SINCRONIZADO: seguro para subprocesos
  2. val value by lazy(LazyThreadSafetyMode.SYNCHRONIZED){ ... }
    

val value by lazy(LazyThreadSafetyMode.PUBLICATION)

Nota : No pude pensar en ningún caso de uso para este modo que no sea el registro, si conoce alguno, agréguelo en los comentarios.

3. NINGUNO : no apto para subprocesos

val value by lazy(LazyThreadSafetyMode.NONE)

Tenga cuidado al usar este modo porque no se usan bloqueos para sincronizar el acceso al valor de la instancia Lazy ; si se accede a la instancia desde varios subprocesos, su comportamiento no está definido.

El mejor caso de uso es cuando está seguro de que está usando solo un hilo como MainThread en Android.

Sugerencia: para simplificar su vida, puede usar una función que devuelva una propiedad perezosa con el modo NINGUNO .

fun <T> fastLazy(initializer: () -> T): Lazy<T> =    lazy(LazyThreadSafetyMode.NONE, initializer)

© Copyright 2021 - 2022 | unogogo.com | All Rights Reserved