Channel-channel

• Channel is actually a secure queue, which can be used to connect corporations to achieve communication of different coroutines.

 @Test
    fun `test know channel`() = runBlocking<Unit> {
        val channel = Channel<Int>()
        // producer
        val producer = GlobalScope.launch {
            var i = 0
            while (true) {
                delay(1000)
                channel.send(++i)
                println("send $i")
            }
        }
        //consumer
        val consumer = GlobalScope.launch {
            while (true) {
                val element = channel.receive()
                println("receive $element")
            }
        }
        joinAll(producer, consumer)
    }

Channel capacity

• Channel is actually a queue. There must be a buffer area in the queue. Once this buffer is full, no one has always called Receive and takes the function.
  Send needs to hang up. Drive the rhythm of the receiving end to slow down, and found that Send will always hang up until the Receive will continue to execute.

@Test
    fun `test know channel2`() = runBlocking<Unit> {
        val channel = Channel<Int>()
        // producer
        val producer = GlobalScope.launch {
            var i = 0
            while (true) {
                delay(1000)
                channel.send(++i)
                println("send $i")
            }
        }
        //consumer
        val consumer = GlobalScope.launch {
            while (true) {
                delay(2000)
                val element = channel.receive()
                println("receive $element")
            }
        }
        joinAll(producer, consumer)
    }

Iterate Channel

• Channel itself is indeed like a sequence, so when we read, we can directly obtain a Channel's Iterator.

 @Test
    fun `test iterate channel`() = runBlocking<Unit> {
        val channel = Channel<Int>(Channel.UNLIMITED)
        // producer
        val producer = GlobalScope.launch {
            for (x in 1..5) {
                channel.send(x * x)
                println("send ${x * x}")
            }
        }
        //consumer
        val consumer = GlobalScope.launch {
            /*val iterator = channel.iterator()
            while (iterator.hasNext()){
                val element = iterator.next()
                println("receive $element")
                delay(2000)
            }*/
            for (element in channel) {
                println("receive $element")
                delay(2000)
            }
        }
        joinAll(producer, consumer)
    }

Produce and Actor

• Constructing a convenient way for producers and consumers
• We can start a producer coroutine through the Produce method and return a ReceiveChannel. Other corporates can use this Channel to receive the data.
  Conversely, we can use ACTOR to start a consumer corporation.

 @Test
    fun `test fast producer channel`() = runBlocking<Unit> {
        val receiveChannel: ReceiveChannel<Int> = GlobalScope.produce<Int> {
            repeat(100) {
                delay(1000)
                send(it)
            }
        }
        val consumer = GlobalScope.launch {
            for (i in receiveChannel) {
                println("received: $i")
            }
        }
        consumer.join()
    }

    @Test
    fun `test fast consumer channel`() = runBlocking<Unit> {
        val sendChannel: SendChannel<Int> = GlobalScope.actor<Int> {
            while (true) {
                val element = receive()
                println(element)
            }
        }
        val producer = GlobalScope.launch {
            for (i in 0..3) {
                sendChannel.send(i)
            }
        }
        producer.join()
    }

Channel's closure

• The Channel returned by Produce and ACTOR will be closed as the corresponding coroutine is completed. It is also this that Channel is called a thermal data stream.
• For a Channel, if we call its Close method, it will immediately stop receiving new elements, that is to say, at this time its iSCloseDForsnd will return True immediately. And because of the existence of the Channel buffer, there may be some elements that may not be processed at this time, so it is necessary to wait for all elements to be read after being read.
• Channel's life cycle is best maintained by the leading party, and it is recommended that the leading party is closed.

@Test
    fun `test close channel`() = runBlocking<Unit> {
        val channel = Channel<Int>(3)
        // producer
        val producer = GlobalScope.launch {
            List(3) {
                channel.send(it)
                println("send $it")
            }
            channel.close()
            println(
                """close channel. 
                | -CloseForSend:${channel.isClosedForSend} 
                | -CloseForReceive: ${channel.isClosedForReceive}""".trimMargin()
            )
        }
        //consumer
        val consumer = GlobalScope.launch {
            for (element in channel) {
                println("receive $element")
                delay(1000)
            }
            println(
                """After Consuming. 
                | -CloseForSend:${channel.isClosedForSend} 
                | -CloseForReceive: ${channel.isClosedForReceive}""".trimMargin()
            )
        }
        joinAll(producer, consumer)
    }

BroadcastChannel

• As mentioned earlier, there is a pair of situations in the Channel. From the perspective of data processing itself, although there are multiple receivers,
  However, the same element will only be read by one receiving end, and the broadcast is not the same. There is no mutual exclusion behavior in multiple receivers.

  @Test
    fun `test broadcast`() = runBlocking<Unit> {
//        val broadcastChannel = BroadcastChannel<Int>(Channel.BUFFERED)
        val channel = Channel<Int>()
        val broadcastChannel = channel.broadcast(3)
        val producer = GlobalScope.launch {
            List(3) {
                delay(100)
                broadcastChannel.send(it)
            }
            broadcastChannel.close()
        }
        List(3) { index ->
            GlobalScope.launch {
                val receiveChannel = broadcastChannel.openSubscription()
                for (i in receiveChannel) {
                    println("[#$index] received: $i")
                }
            }
        }.joinAll()
    }