Почему при увеличении числа в корутинах, число иногда имеет другое значение?

Question

[foonfyrick]

1)Почему, если я пишу этот код, то в runBlocking у меня иногда меняется значение переменной, иногда оно 20 000, а иногда чуть меньше, но стоит мне удалить весь CoroutineScope и оставить только runBlocking, то у меня значение переменной всегда равно 10 000.
2)И почему вообще в первом случае, когда есть и coroutineScope и runBlockin у меня переменная в обоих случаях стремится к 20 000, а не к 10 000? Такое ощущение, что повторы пытаются сложиться, но в runBlockin они складываются криво.

Код:

val int = AtomicInteger()

            CoroutineScope(Dispatchers.IO).launch {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
                Log.e("@@@ CoroutineScope @@@", int.toString())
            }


        runBlocking {
            withContext(Dispatchers.IO) {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
            }
            Log.e("@@@ withContext @@@", int.toString())
        }

Скрины:

Comments

[koperagen]

Что ты пытаешься сделать?

[foonfyrick]

koperagen, изучаю то, как работаю корутины

[koperagen]

foonfyrick, У тебя постоянно выводится разный ответ, потому-что вывод происходит до того, как все запущенныев CoroutineScope(Dispatchers.IO).launch { ... } корутины закончат свое выполнение. Попробуй посмотреть дебагером значение переменной int или добавить перед Log.e("@@@ withContext @@@", int.toString()) задержку в, скажем, пару секунд.
По каким источникам изучаешь?

[foonfyrick]

koperagen, Действительно, результат выводится до того как все корутины отработали, я сначала поставил задержку перед Log.e("@@@ withContext @@@", int.toString()), результат стал показывать 20 000, потом я поставил задержку перед Log.e("@@@ CoroutineScope @@@", int.toString()), и здесь тоже всегда стал результат 20 000. Теперь у меня возник другой вопрос, я подумал, что если я задержку не использую, то у меня в withContext чаще выводится результат 20 000, а в CoroutineScope он почти всегда меньше, колеблется от 14 000 до 19 600, вдруг CoroutineScope работает медленнее чем withContext, я поменял их местами,

runBlocking {
            withContext(Dispatchers.IO) {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
            }
            Log.e("@@@ withContext @@@", int.toString())
        }

        CoroutineScope(Dispatchers.IO).launch {
            repeat(100) {
                launch {
                    repeat(100) {
                        int.incrementAndGet()
                    }
                }
            }
            Log.e("@@@ CoroutineScope @@@", int.toString())
        }

теперь в withContext у меня всегда выводится 10 000, а в CoroutineScope от 14000 до 19 600,
почему 10 000 а не 20 000? я вообще запутался как и в каком случае корутины складываются, и почему вообще они складываются, ведь везде, где я про них читал, об этом ни слова.

[koperagen]

foonfyrick, Встречный вопрос. Почему там должно быть 20000?
Не понял начнет того что с чем складывается.

[foonfyrick]

koperagen,
в этом варианте, в обеих корутинах результат переменной 20 000

val int = AtomicInteger()

            CoroutineScope(Dispatchers.IO).launch {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
                Log.e("@@@ CoroutineScope @@@", int.toString())
            }


        runBlocking {
            withContext(Dispatchers.IO) {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
            }
            Log.e("@@@ withContext @@@", int.toString())
        }

а в этом варианте, я их местами поменял и первая корутина withContext стала выводить результат 10 000, а coroutinescope по прежнему 20 000

runBlocking {
            withContext(Dispatchers.IO) {
                repeat(100) {
                    launch {
                        repeat(100) {
                            int.incrementAndGet()
                        }
                    }
                }
            }
            Log.e("@@@ withContext @@@", int.toString())
        }

        CoroutineScope(Dispatchers.IO).launch {
            repeat(100) {
                launch {
                    repeat(100) {
                        int.incrementAndGet()
                    }
                }
            }
            Log.e("@@@ CoroutineScope @@@", int.toString())
        }

вот про это я не понял, но это не суть важно, на выходных попробую еще поразбираться с корутинами, напишите любой ответ на вопрос отмечу решением.

[destbro]

foonfyrick, в последнем случае runBlocking блокирует поток пока не дойдет до 10000 и отобразит, потом сработает асинхроный CoroutineScope блок, который добавить ещё 10000.

Если поменять местами то когда CoroutineScope запустится выполнение сразу переидет к runBlocking. В этом случае CoroutineScope может вывести на экран значение которое int получила в runBlocking блоке тоже. Тут как бы они одновременно выполняются, по этому и такой результат.

Answer 1

[koperagen]

В комментарии обсудили (: Лог выводится до того, как все корутины отработают увеличение счетчика