Depende de lo que estés tratando de lograr.

Para el escenario 2, la mayoría de las veces lo que desea es un valor que se calcule una vez y se reutilice más tarde. Para este caso de uso, puede usar delegados lazy como este:

 class MyClass { // will be computed the first time it's accessed, and then reused val value by lazy { computeExpensiveValue() } } fun computeExpensiveValue(): Int { // some complex stuff return 42 }

Nunca encontré el escenario 1, pero en los casos en que la lazy no es suficiente, de hecho podría usar booleanos atómicos para enfoques CAS o bloqueos. Compruebe, por ejemplo, kotlinx.atomicfu .

Si usa corrutinas de Kotlin, es posible que desee verificar otras primitivas de sincronización como Mutex y Semaphore . Pero, en general, es preferible hacer que las corrutinas se comuniquen a través de canales en lugar de compartir un estado mutable.

No está muy claro lo que pides. Pero suponiendo que desea asegurarse de que algún código se ejecute (o no se ejecute) solo por primera vez y la función se puede invocar al mismo tiempo (porque solicitó "atómico"), entonces la respuesta es: no y no. Ambos ejemplos de código no son seguros para subprocesos y pueden dar lugar a que más de la primera llamada se maneje de una manera especial.

Esto no se debe a que boolean no sea atómico, sino a que su código no es atómico. Dos o más subprocesos simultáneos pueden verificar isFirstTime al mismo tiempo, antes de que otro subproceso lo cambie a false .

Puede resolver esto de varias maneras, por ejemplo, usando mutexes, pero probablemente la más fácil y de mayor rendimiento es usar una de las operaciones de comparación e intercambio . Por ejemplo:

 val isFirstTime = AtomicBoolean(true) fun notForFirstTime(){ if (!isFirstTime.getAndSet(false)) { jobDone() } } fun onlyForFirstTime(){ if (isFirstTime.getAndSet(false)) { jobDone() } }