Goal lazy map where we only need the getter supporting multithreaded access Is there a better way ```val getValuesForKey String gt Set lt String gt = object String gt Set lt String gt val map = mutableMapOf lt String Set lt String gt gt override fun invoke key String Set lt String gt = synchronized this map getOrPut key calculateValuesForKey key ```

but I would both lean on existing functionality to build the map as well as use per key locking ```class Memo lt K V gt val block K gt V K gt V private val cache ConcurrentMap lt K Lazy lt V gt gt = ConcurrentHashMap override fun invoke key K V = cache computeIfAbsent key lazy block it value ```

Goal lazy map where we only need the getter supporting multi kotlinlang #codereview

Channels

100daysofcode

androidgithubprojects

cincinnati-user-group

competitive-programming

event21-community-content

java-to-kotlin-refactoring

jvm-ir-backend-feedback

kotlin-multiplatform-contest

kotlinultimatechallenge

myndocs-oauth2-server

naming

navigation-architecture-component

practical-functional-programming

proguard

prozis-android-backup

refactoring-to-kotlin

russian-kotlinasfirst

skia-wasm-interop-temp

stayhungrystayfoolish

swagger-gradle-codegen

tricity-kotlin-user-group

Title

Mark

04/01/2022, 9:19 AM

Goal: lazy map (where we only need the getter) supporting multithreaded access. Is there a better way?

val getValuesForKey: (String) -> Set<String> =
    object : (String) -> Set<String> {
        val map = mutableMapOf<String, Set<String>>()

        override fun invoke(key: String): Set<String> =
            synchronized(this) {
                map.getOrPut(key) {
                    calculateValuesForKey(key)
                }
            }
    }

ephemient

04/01/2022, 2:47 PM

https://wiki.sei.cmu.edu/confluence/plugins/servlet/mobile?contentId=88487798 if you do have to use traditional Java locking, use a private lock to avoid other callers from interfering

but I would both lean on existing functionality to build the map as well as use per-key locking,

class Memo<K, V>(
    val block: (K) -> V,
) : (K) -> V {
    private val cache: ConcurrentMap<K, Lazy<V>> = ConcurrentHashMap()
    override fun invoke(key: K): V =
        cache.computeIfAbsent(key) { lazy { block(it) } }.value
}

Mark

04/02/2022, 1:49 AM

Thanks, though I was hoping to just use kotlin standard library

ephemient

04/02/2022, 2:31 AM

synchronized is JVM-only so you're not losing any portability by using java.util.concurrent

Mark

04/02/2022, 3:50 AM

I’m curious, why would

synchronized

be added to the standard lib, when it’s JVM-only?

ephemient

04/02/2022, 5:11 AM

quite a few parts of kotlin-stdlib are JVM-only, it's marked in the documentation. (there's also JS-only and native-only parts as well)

for example,

.toSortedSet()

and

.toSortedMap()

are also JVM-only,

console

and

.unsafeCast()

are JS-only,

Char.toChars()

and

getTimeMicros()

are native-only

there's also parts that of kotlin-stdlib that are only on specific JVM versions, such as

.use()

on Java 7+ and

.asStream()

on Java 8+

in the case of

synchronized

, there's no other way to get the same access to that functionality of the JVM without compiler support, but it doesn't make any sense in JS (which is single-threaded) and the mechanisms on native are incompatibly different, so it's JVM-only

:thank-you: 1

7 Views

#codereview Join Slack