Hey guys, So I have a server class which contains a map of strings to bots, and theres this function in the server class called runBots() which run all the bots. This is what I have for a implementation:

fun runBots() = runBlocking {
        try {
            bots.forEach {
                val one = launch { it.value.setConnection(); }
                one.join()
                delay(3000L)
                if(it.value.running) {
                    it.value.Connect()
                }
            }
        } catch(e: Throwable) {
            bots.forEach { if(!it.value.running) it.value.Connect() }
        }
    }

"bots" here is the map of strings to bots. Each bot has a Connect() function(a async function) which runs the all the bot's main loop. The problem is that the bot doesnt run, after the server class calls it's runBots function.

Initialised
Connnected: true
Defined bot
Added bot
[main] Connecting....
[main] Sending nick...
Sending nick: NICK Kraken3635

[main] Sending user...
Sending user: USER Nani 0 * :Nani

[main] Connected!
[DefaultDispatcher-worker-1] I'm now in Connect!
[DefaultDispatcher-worker-1] Entering loop...

async you mean you do launch inside Connect?

yes each Connect is a loop which runs the internals of each bot, and the declaration of Connect is as such:

fun Connect() = GlobalScope.async { ... }

i see. you should use structured concurrency:

fun CoroutineScope.Connect() = launch { ... }

in this case your

runBlocking

call does not exit until child launches complete whatever they do

ok, where can i read more about this?

https://medium.com/@elizarov/structured-concurrency-722d765aa952 check this first

thnx a lot

https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/basics.md#structured-concurrency and then docs

thnx

Yes, Connect with coroutine scope is preferred way to implement this, but you can fix existing code if you

join

result of connect, but to do this in parallel you can replace forEach with map and than call joinAll on list of jobs

and replace

async

with

launch

then

Only if you need result of operation

val one = launch { it.value.setConnection(); }
                one.join()

what is the reason behind this?

Yes, Sergey was faster :) Also want to ask about this code, it doesn't make sense

Also should i make the server class the CoroutineScope main class or should i make the bot class the coroutinescope main class?

Actually I really curious why Connect calls launch inside, usually you don't need such code

well my purpose was to create a bot's main loop on its own coroutine

Why?

well, to make it run faster maybe, i could initialise many bots and run them parallely then

Much better to parallel operation only when you need it

ok

Also you avoid problems with global scope

ok thanks

It uses the same approach as you original code, but has remark about this and then demonstrates recommended approach:

This programming style with async functions is provided here only for illustration, because it is a popular style in other programming languages. Using this style with Kotlin coroutines is strongly discouraged for the reasons that are explained below.

yeah its the same page given above

Yeah, right