Non-blocking alternative to Object.wait()? - multithreading

Question

I have one thread receiving packets from a local server:
// Shared object:
#Volatile lateinit var recentPacket: Packet
val recvMutex = Object()
// Thread code:
thread(isDaemon = true) {
while (true) {
val packet = readPacket()
synchronized(recvMutex) {
recentPacket = packet
recvMutex.notifyAll()
}
}
}
And I have multiple other threads waiting for packets, each of which should get the same packet that was just received:
suspend fun receive() {
return synchronized(recvMutex) {
recvMutex.wait() // non-blocking alternative to this?
recentPacket
}
}
It works, but Object.wait() blocks the thread. Is there a way to avoid this?

Answer 1

It works, but Object.wait() blocks the thread. Is there a way to avoid this?
Yes, but it means removing the complete wait-notify idiom you use now and replacing it with Kotlin's native BroadcastChannel.
Here is a basic example with two receivers and five packets being broadcast:
import kotlinx.coroutines.experimental.asCoroutineDispatcher
import kotlinx.coroutines.experimental.channels.BroadcastChannel
import kotlinx.coroutines.experimental.channels.SubscriptionReceiveChannel
import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
private val threadPool = Executors.newCachedThreadPool() as ExecutorService
val MyPool = threadPool.asCoroutineDispatcher()
fun main(args: Array<String>) {
val packetChannel = BroadcastChannel<Packet>(1)
(1..2).forEach {
launch(MyPool) {
receivePackets(it, packetChannel.openSubscription())
}
}
runBlocking {
(1..5).forEach {
packetChannel.send(Packet(it))
delay(100)
}
}
threadPool.shutdown()
}
suspend fun receivePackets(index: Int, packetChannel: SubscriptionReceiveChannel<Packet>) {
while (true) {
println("Receiver $index got packet ${packetChannel.receive().value}")
}
}
data class Packet(
val value: Int
)
Expect to see output such as this:
Receiver 1 got packet 1
Receiver 2 got packet 1
Receiver 2 got packet 2
Receiver 1 got packet 2
Receiver 1 got packet 3
Receiver 2 got packet 3
Receiver 1 got packet 4
Receiver 2 got packet 4
Receiver 1 got packet 5
Receiver 2 got packet 5

Answer 2

Coroutines seem to be in an experimental state; I suggest waiting until those mature before using them. See https://kotlinlang.org/docs/reference/coroutines.html#experimental-status-of-coroutines
I the mean time, you might try a ThreadPool:
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.util.concurrent.Executors
import kotlin.concurrent.thread
fun start() {
val pool = Executors.newFixedThreadPool(10)
thread(isDaemon = true) {
val socket = DatagramSocket(12345)
while (!socket.isClosed) {
val packet = DatagramPacket(ByteArray(1000), 0)
socket.receive(packet)
pool.submit({
receive(packet)
})
}
}
pool.shutdown()
}
fun receive(packet: DatagramPacket) {
println(String(packet.data, 0, packet.length))
}
Asynchronous IO might be useful; You can look into Java Selectors