ConcurrentHashMap.kt

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import kotlinx.coroutines.newFixedThreadPoolContext
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import java.util.UUID
import java.util.concurrent.ConcurrentHashMap

fun main() = runBlocking {
    val testyMcTest = TestyMcTest()
    val scope = CoroutineScope(newFixedThreadPoolContext(4, "synchronizationPool"))
    scope.launch {
        val jobs: List<Job> = 1.rangeTo(NUMBER_OF_COROUTINES).map {
            launch {
                testyMcTest.addOnePairToMap()
                testyMcTest.loopThroughMap()
            }
        }

        jobs.forEach {
            it.join() // wait for all coroutines to finish
        }
    }.join()

    println("I should be equal to $NUMBER_OF_COROUTINES. Am I?")
    println("Map size is ${testyMcTest.map.size}")
}

class TestyMcTest {
    private val _concurrentHashMap = ConcurrentHashMap<UUID, UUID>()
    val map: ConcurrentHashMap<UUID, UUID>
        get() = _concurrentHashMap

    suspend fun addOnePairToMap() {
        withContext(Dispatchers.IO){
            val randomUUID = UUID.randomUUID()
            _concurrentHashMap[randomUUID] = randomUUID
        }
    }

    suspend fun loopThroughMap() {
        withContext(Dispatchers.Default){
            map.forEach {
                // whatever
                it.key.toString()
            }
        }

    }
}

val NUMBER_OF_COROUTINES = 1000