What is channel

go channel is a core data type of go language, which can be understood as a pipeline. Concurrent core units can send or receive data through channel for communication to realize concurrent synchronization.

channel type

channel type can have direction. Suppose T is a type:

1. Channel t is a bidirectional channel type. The compiler allows sending and receiving of bidirectional channels at the same time.
2. Channel < - t is a write only channel type, and the compiler is only allowed to send data to the channel.
3. < - channel t is a read-only channel type. The editor is only allowed to receive data from the channel.
   In go language, create channels through chan, and create syntax:

   channel1 := make(chan int)  //Bidirectional channel, readable and writable
   channel2 := make(chan<- int)  //One way write only channel
   channel3 := make(<-chan int)  //Unidirectional read-only channel

   channel_name represents the declared pipeline name, and Type represents the data Type transmitted by the pipeline. The data types supported by the pipeline include: int,string,struct, etc.

channel classification

channel can be divided into non buffered type and buffered type:

• Unbuffered type channel
  After a thread sends messages to this channel, it will block the current thread until other threads receive messages from this channel. Create syntax:

  intchan := make(chan int)

• Buffer type channel
  A buffered channel is the number of messages that can be buffered. When the number of messages is less than the specified value, there will be no blocking. After that, it will be blocked. You need to wait for other threads to receive channel processing. Create syntax:

  intchan := make(chan int,3) 

Some operations of channel

Suppose ch is a channel.

• Close (close a channel)

  close(ch)

  Note: if ch is a nil channel or ch has been closed, the above close(ch) will trigger panic
• Send a value to channel ch

  ch<-c

  Note: ch can only be a two-way channel or a one-way write only channel.
• Receive a value from channel ch

  c <-ch

  Note: the channel ch can only be a two-way channel or a one-way read-only channel
• Get channel capacity

  cap(ch)

• Get channel length

  len(ch)

  Note: the len function returns the number of elements in the current channel, and the cap function returns the total number of elements that can be stored in the current channel.

Some channel usage examples

1. Data synchronization through non buffered channel

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int)
    done := make(chan string)
    go func(ch chan<- int, x int) {
        time.Sleep(time.Second * 5)
        ch <- x * x * x
    }(c, 10)
    go func(ch <-chan int) {
        data := <-ch
        fmt.Println(data)
        s := "Program end"
        done <- s
    }(c)
    fmt.Println("Program start")
    fmt.Println(<-done)
}

Result output:

Program start
1000
 Program end

1. Non buffered channel timeout control

package main

import (
    "fmt"
    "time"
)

func main() {
    select {
    case <-dowork():
        fmt.Println("The task is completed within the specified time!")
    case <-time.After(time.Second * 2):
        fmt.Println("Task timeout!!!")
    }
}

func dowork() <-chan int {
    ch := make(chan int)
    go func() {
        fmt.Println("start-up")
        time.Sleep(time.Second * 3)
        ch <- 0
    }()
    return ch
}

Result output:

start-up
 Task timeout!!!

1. Implementation of producer consumer model with buffered channel

package main

import (
    "fmt"
    "time"
)

func producer(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch chan int, done chan string) {
    for i := 0; i < 5; i++ {
        go func(id int) {
            for {
                data, ok := <-ch
                if !ok {
                    done <- "done"
                    return
                } else {
                    fmt.Printf("consumer %v，Complete the task %v\n", id, data)
                    time.Sleep(time.Second * 2)
                }
            }
        }(i)

    }
}

func main() {
    done := make(chan string)
    ch := make(chan int, 10)
    go producer(ch)
    go consumer(ch, done)
    <-done
    fmt.Println("Mission accomplished")
}

Result output:

Consumer 4, complete task 0
 Consumer 1, complete task 1
 Consumer 2, complete task 2
 Consumer 3, complete task 3
 Consumer 0, complete task 4
 Consumer 0, complete task 5
 Consumer 3, complete task 8
 Consumer 2, complete task 6
 Consumer 1, complete task 9
 Consumer 4, complete task 7
 Mission accomplished

1. Concurrent quantity control with buffered channel

package main

import (
    "fmt"
    "time"
)

func handleEvent(done chan string, task chan bool) {
    for i := 0; i < 10; i++ {
        task <- true
        go func(id int) {
            fmt.Printf("Handling events %v\n", id)
            time.Sleep(time.Second * 1)
            <-task
            if id == 9 {
                done <- "done"
            }
        }(i)
    }

}

func main() {
    done := make(chan string)
    task := make(chan bool, 2) //The number of merging method is controlled to 2
    go handleEvent(done, task)
    <-done
    fmt.Println("Mission accomplished")
}

Result output:

Handling event 1
 Processing event 0
 Handling event 2
 Handling event 3
 Handling event 5
 Handling event 4
 Handling events 7
 Handling event 6
 Handling event 8
 Handling event 9
 Mission accomplished

Precautions for using channel

1. Closing a nil channel or a closed channel will generate a panic.
2. Sending data to a closed channel will also cause panic.
3. Sending data to or receiving data from a nil channel will permanently block the current protocol.