A modern programming language that makes developers happier.

kotlinlang

hi! is it safe to use `TransferMode.UNSAFE` when we properly synchronise everything using posix mutexes and we don’t have references to the objects in the passing worker?

for example here:
```
val worker = Worker.start()
    worker.execute(
        mode = TransferMode.UNSAFE,
        producer = { Unit },
        job = {
            val a = mutableListOf&lt;Int&gt;()
            val worker2 = Worker.start()
            worker2.execute(
                mode = TransferMode.UNSAFE,
                producer = { a },
                job = { list -&gt;
                    sleep(1)
                    GC.collect()
                    sleep(1)
                    list.add(1)
                    print(list)
                }
            )
        }
    )
```
is it guaranteed that list `a` will not be GCed after worker1 finished?

The safe/unsafe is about the producer and Unit

I’d say “yes” but would want to double check and don’t have time today…

so it means that list `a` will be collected by GC when the outer worker is finished?

No. The GC doesn’t really work the way you think it does. Reference counting on non-frozen state is not atomic. You’ll have memory crashes and/or leaks (potentially).

<https://medium.com/@kpgalligan/kotlin-native-stranger-threads-ep-1-1ccccdfe0c99>

<https://medium.com/@kpgalligan/kotlin-native-stranger-threads-ep-2-208523d63c8f>

I talk about unsafe in those and why you can’t do that

Is there any good chance that memory model will allow sharing?

You can share frozen state. You cannot share “regular” mutable state. You can _pass_ mutable state, but that will be syntactically complex in the case you’ve presented.

You can also use mutable frozen collections, but if performance is a concern, be advised it’ll be different than you’re used to. <https://github.com/touchlab/Stately>

Thanks for the readings. Do you know if there are any known plans to update the memory model so it will allow mutable state sharing?

That’s a long discussion. I doubt it, except in limited cases. It was designed for safer concurrency, so they’d need to “give up” on that plan. My thoughts: <https://medium.com/@kpgalligan/saner-concurrency-74b0bf8ed446>