val reader =        produce<String>(<http://Dispatchers.IO|Dispatchers.IO>, capacity = 1024) {
            input.forEachLine { runBlocking { send(it) } }
            this.close()
        }

        val writer = produce<String>(context, capacity=8) {
            reader.consumeEach {
                val tokenized = tokenizerFactory.create(pp.preProcess(it)).tokens.joinToString(" ")
                send(tokenized + "\n")
            }
        }

        writer.consumeEach {
            output.appendText(it)
        }

runBlocking {
            val channel = produce<Double>(capacity = 1024) {
                while(true) {
                    send(Math.random())
                }

            }

            repeat(8) {
                launch {
                    for (item in channel) {
                        println(item)
                    }
                }
            }

            delay(500)
            channel.cancel()
        }

runBlocking {
            val channel = produce<Double>(capacity = 1024) {

                var x = 0
                while(true) {
                    send(Math.random())
                    x++
                    if(x > 100) {
                        break //closing
                    }
                }

            }

            repeat(8) {
                launch {
                    for (item in channel) {
                        println(item)
                    }
                }
            }

        }
        println("all done")

val reader = produce<String>(capacity = 1024) {
            input.useLines {
                val iterat = it.iterator()
                while (iterat.hasNext()) {
                    send(iterat.iterator().next())
                }
            }
            println("Can close now")
            this.close()
        }

        val writer = launch(<http://Dispatchers.IO|Dispatchers.IO>) {
            writerChannel.consumeEach {
                output.appendText(it)
            }
        }

        repeat(8) {
            println("Analyzer number $it")
            for (x in reader) {
                val tokenized = tokenizerFactory.create(pp.preProcess(x)).tokens.joinToString(" ")
                writerChannel.send(tokenized + "\n")
            }
        }

        writerChannel.close()
        writer.join()

Analyzer number 0 (spent all the processing time here)
Can close now
Analyzer number 1 (go really quickly across all of the following)
Analyzer number 2
Analyzer number 3
Analyzer number 4
Analyzer number 5
Analyzer number 6
Analyzer number 7

appendText

output.bufferedWriter().use { out ->
        input.bufferedReader().use { inp ->
            while (isActive) {
                val line = inp.readLine() ?: break
                out.write(line + "\n")
            }
        }
    }
}

take x thousands of lines