Is it good idea to use atomic boolean in kotlin?

Question

Hey I am learning in atomic in kotlin. I am wondering is this good idea to use atomic boolean in my scenario? Can someone suggest, how to do in atomic way.

Scenario 1 Not for first time call

var isFirstTime = true

fun notForFirstTime(){
   if(!isFirstTime){
     jobDone()
   }
  isFirstTime = false
}

Scenario 2 only for first time

var isFirstTime = true

fun onlyForFirstTime(){
   if(isFirstTime){
     jobDone()
   }
  isFirstTime = false
}

Can I do this in atomic way? Also is this good idea?

Atomic booleans could be ok, but what is your actual use-case? Most use cases I encountered for scenario 2 could be achieved more simply by using a `by lazy { ... }` delegate. I don't recall having needed scenario 1 ever. Do you have a more concrete example? — Joffrey, Feb 21 '22 at 17:31
@Joffrey thanks for replying me. Sorry I don't have more example. I just have this 2 scenario in my code. Yes scenario 2 is most common, I think. Can you give me example of `by lazy { ... }` delegate. — Kotlin Learner, Feb 21 '22 at 17:34

Joffrey · Answer 1 · 2022-02-21T19:06:05.510

It depends on what you're trying to achieve.

For scenario 2, most of the time what you want is a value that's computed once and reused later. For this use-case, you can use lazy delegates like this:

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
}

I never encountered scenario 1, but in cases where lazy is not sufficient you could indeed use atomic booleans for CAS approaches, or locks. Check for instance kotlinx.atomicfu.

If you're using Kotlin coroutines, you might want to check other synchronization primitives like Mutex and Semaphore. But in general it's preferable to make coroutines communicate over channels rather than sharing mutable state.

great explanation thanks. – Kotlin Learner Feb 21 '22 at 17:58 — Kotlin Learner, Feb 21 '22 at 17:58

score 1 · Accepted Answer · answered Feb 21 '22 at 19:44

It is not very clear what do you ask. But assuming you want to make sure some code is executed (or not executed) only for the first time and the function may be invoked concurrently (because you asked for "atomic") then the answer is: no and no. Both your code samples aren't thread-safe and may result in more than the first call to be handled in a special way.

This is not because boolean is not atomic, but rather because your code is not atomic. Two or more concurrent threads may check for isFirstTime at the same time, before other thread will flip it to false.

You can solve this in multiple ways, for example using mutexes, but probably the easiest and most performant is to use one of compare and swap operations. For example:

val isFirstTime = AtomicBoolean(true)

fun notForFirstTime(){
  if (!isFirstTime.getAndSet(false)) {
    jobDone()
  }
}

fun onlyForFirstTime(){
  if (isFirstTime.getAndSet(false)) {
    jobDone()
  }
}

you understand correctly. Sorry for my wrong english. I am learning phase. Sometimes it really hard me to explain, what I need. But thanks a million — Kotlin Learner, Feb 21 '22 at 20:47

Is it good idea to use atomic boolean in kotlin?

2 Answers2