Hello how could I make a function repeatable after a period of time using coroutines?

What's the state of

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

? I'm seeing different behavior to the documentation, and some scheduling weirdness

I am writin a lib: https://github.com/jasync-sql/jasync-sql and just started to use coroutines internal (not in exposed api). Since this is new I am not using experimental packages. I wonder how this affects lib users? They will not be able to use it if they are using experimental coroutines?

Unanswered questions I couldn't find in docs:

Where to

supervisorScope { }

and

coroutineScope { }

get their

CoroutineScope

from?

I have a

produce { }

that sends download status to a notification service, so if there's an exceoption I'd like to be able to send an error message. It looks like

try { } catch() { }

is unreliable (https://github.com/Kotlin/kotlinx.coroutines/issues/361), and installing a

CoroutineExceptionHandler

on

produce

I won't be able to get to its channel to report status... is there any better way to do this?

@elizarov Would you be interested in this contribution?

public suspend inline fun <T : Closeable?, R> T.useCancellably(
        crossinline block: (T) -> R
): R = suspendCancellableCoroutine { cont ->
    cont.invokeOnCancellation { this?.close() }
    use(block)
}

Are workers as a concept planned for the stable release of coroutines, or coming later?

Is something wrong with my code here(doing java.io.File writing in a coroutine)

class AsyncLogger : AbstractLogger {

    constructor(filepath: String,name: String) : super() {
        var file = File(filepath)
        file.mkdirs()
        filename = "$filepath/$name"
        file = File(filename)
    }

    suspend fun log(toLog: Boolean,msg: String) = coroutineScope {
        GlobalScope.launch {
            if (toLog)
                writeToFile(msg)
        }
    }

    suspend fun log(toLog: Boolean,toFile: Boolean,msg: String) = coroutineScope {
        GlobalScope.launch {
            if(toLog)
                when(toFile) {
                    true -> writeToFile(msg)
                    false -> writeToFile(msg)
                }
        }
    }

    override suspend fun writeToSTDOUT(msg: String) =
            println(message = "[${Thread.currentThread().name}]: $msg")

    override suspend fun writeToFile(msg: String): Job = coroutineScope {
        GlobalScope.launch {
            val stream = RandomAccessFile(filename, "rw")
            val channel = stream.channel
            var lock: FileLock? = null
            try {
                lock = channel.tryLock()
            } catch (e: OverlappingFileLockException) {
                stream.close()
                channel.close()
            }
            stream.writeBytes(msg + '\n')
            lock?.release()
            stream.close()
            channel.close()
        }
    }

}

Can you give me an example particular to this use case ? @elizarov

What is the purpose of

join

now that the outer scope will wait for all functions launched within to complete?

I'm using ticker function to create a repeating task which repeats after 1 min. I have the receive part of the code done. But the problem is in the apply part. Where do I sent the function which calls the apply code of the ticker? The ticker itself is running inside a while loop.

@SUPERCILEX I can't delay inside the main thread because it should wait for 1 minute, which is a long time for the app(its networked)

I see this remark often, and there's something here I don't understand. If I call

.receive()

on a non-blocking NIO channel, it will immediately return with either some available data, or

null

. So if I were to use this in a coroutine, I'd have to do this in an infinite loop, no? Something like:

while(true) {
   channel.receive(buffer)
   // handle data if available
}

If I were to implement it like this, wouldn't that make the CPU load 100%? Or am I supposed to implement a delay here to prevent this?

@elizarov hi! i see coroutines start 1.0.0 RC versions, so in 1.0.0 release version not planned multithreaded support?

where can I find the source for suspendCoroutine? Am I looking in the wrong repo?

Is there any way to have set-like functionality for a channel? Basically a way for a channel to not accept a value if it already has that value in its "queue".

guys, what is the best way to wait all results of async calls inside a for loop ?

i can’t use a parent job, its deprecated. i cant find the new way

How to convert those functions with a complete listener to a suspend function?

Might anything here be worth considering before 1.0 release? http://250bpm.com/blog:137

Hi!, After migrating to 1.3-RC I get this compiler warning:

w: -Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond

I’m not sure where to disable it as I don’t have manual flags passed to the compiler process. Any help is appreciated, thanks!

I am thinking about writing actors library, do you think it is required?