What’s the best way to mix a long running loop with coroutines. For example, I want to do something like

while (true) { consumer.take() }

, where consumer.take is a blocking call on a JMS client. Normally, I’d launch a new thread for this, and then shut down the thread once the program exits.

You'll still have to have some thread doing the same thing with coroutines. Typically this style of coroutine gets put on the

<http://Dispatchers.IO|Dispatchers.IO>

thread pool, which has a lot of extra threads that can be blocked, or you might want to have your own thread pool with a similarly high number of threads. In any case, I would

yield()

after every

take()

to participate in cooperative cancellation, but otherwise, the loop is still how you handle this in coroutines. If you wanted to also run some code inside the loop, you might send the data over

Channel

-- do

yourIOScope.produce { while (true) channel.send(consumer.take()) }

, and then use the resulting channel to retrieve results when you need them, in a suspending manner. But it all depends on your use case.

I would only need one thread for the loop, so I could make a thread for it, and wrap that in a dispatcher. Can I use a dispatcher as the basis to launch a coroutine?

You can also just use

while (isActive)

if the semantics suit your use case well.

while (isActive) { } will block the calling thread, so I need to wrap it in something.

you can use a dispatcher to launch, you just need to wrap it in a Scope:

CoroutineScope(your-dispatcher)

So just working out loud,

val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
    CoroutineScope(dispatcher).launch {
      while (true) {
        val messages = consumer.poll(Duration.ofSeconds(5))
      }
    }

Checking if

isActive

will not block it but will not let other coroutines run cooperatively on the same dispatcher as yield() or other suspending and dispatching function would.

@louiscad sorry, I thought by isActive you just meant some kind of volatile or atomic boolean

You can stop looping when it's no longer active (i.e. cancelled).

Right, that’s what I thought, but while it’s active it’s the same as while true.

not too much, but if you do a hand-off to Channel like I suggested, you gain the ability to suspend in other contexts for the same call

Yeah I want to use a channel (or a flow?) for this

if you use your single-thread like so:

val messages = CoroutineScope(dispatcher).produce {
      while (true) {
        channel.send(consumer.take())
      }
    }

in another coroutine, you can do

messages.receive()

(or similar call) to suspend for the result of

consumer.take

. it will still block the single-thread-dispatcher, but it won't block other threads that use

receive()

I get you, because without the channel, the consumer(s) would themselves also have to block

yes

That’s only an advantage if I have more than one consumer right (I will be doing that)

maybe if you want your code to read in a certain way, it can also be useful. if you have other suspend calls, you probably don't want to have a lot of

withContext

calls in your code, switching from your blocking thread to e.g. a UI thread (not sure if that's relevant to you)

Yeah no UI thread here.

yes, and have the next message already fetched for you as well if you use

produce(capacity = 1)

Would you recommend using produce over manually creating a channel with a buffer ?

yes, because it will handle closing the channel for you on exceptions

ok