Golang channel 的基本使用方法

package main

import (
    "fmt"
    "learner/Add"
    "time"
)

//a. 普通类型，普通变量保存的就是值，也叫值类型
//b. 获取普通变量的内存地址，用&，比如： var a int,获取a的内存地址：&a
//c. 指针类型，指针变量存的就是一个内存地址，这个地址指向值
//d. 获取指针类型所指向的值，使用：*，比如：var *p int,使用*p获取p指向的值
//e. 将一个内存地址给一个指针类型进行赋值(不可以直接将变量赋值给指针,需要将内存地址赋值给指针): var a int=5,var p *int = &a

// 在工程上有两种最常见的并发通信模型: 共享数据和消息通信,go语言选择后者,通过通信进行共享内存
// channel,goroutine 间的通信方式,进程内的的通信.进程间的通信建议使用socket或者http等通信协议.
// channel 是类型相关的,一个channel只能传递一种指定类型的值,这个值需要在声明channel时指定(可以理解为指定元素类型的管道)

// 超时控制的经典实现
func chan_time_out_handler(ch chan int)  (item bool){
    // 使用 select 为channel实现超时机制,select的一个case必须是一个面向channel的操作
    // 定义一个time_out chan
    timeOut := make(chan bool,1)
    go func(){
        time.Sleep(1e9) // 等待一秒钟
        timeOut<- true
    }()
    // 利用time_out这个chan实现超时之后做何操作
    select {
        case a := <- ch: // 尝试从ch这个chan中读取数据
            fmt.Println(a)
            return true
        case <- timeOut: // 在等待时间范围内一直没有从ch中读取到了数据但是从time_out 这个 chan 中读取到了数据
            return false
    }
}

// 只往chan中写入数据
func chan_in(ch_in chan<- int)  {
    for i:=0; i <= 10; i++{
        ch_in <- 1
    }
    // 如果是使用range遍历chan,那么当chan关闭时,读取操作会立即结束,跳出循环(注意,这是channel中可能仍会存在数据),// channel关闭后，其实仍然可以从中读取已发送的数据(使用range无法实现,可以使用常规的循环读取channel的方式)，读取完数据后，将读取到零值，可以多次读取(仍然是零值)
    close(ch_in) // 当多个goroutine都使用了同一个channel时,任何一个goroutine 中关闭了这个了这个channel,其他goroutine将无法继续对这个channel进行读取
}

// 只从chan读出数据
func chan_out(ch_out <-chan int)  {
    // 使用range,当这个channel关闭时,就会跳出循环,但是channel里面仍然可能存在数据
    // x,ok := <- ch_out,如果ok返回的是false,那么就表示这个chan已经关闭
    for value := range ch_out{
        fmt.Printf("+++++++++++++++++%d",value)
    }
}

func main() {

    // 切片和map 都是指针类型的数据,指针类型的数据都可以使用make()进行分配内存
    chs := make([]chan int,10) // 定义一个切片并分配内存,元素是chan类型,这个chan内可以保存的元素为int类型,该切片初始内存可以保存10个元素(不是channel的缓冲区,是切片的初始大小)
    for i := 0; i < 10; i++ {
        chs[i] = make(chan int,3) // 定义一个chan并分配内存,缓冲区大小为3,然后保存到切片中,如果不设置缓冲区,当写入一个元素时,如果这个元素不被读取掉,写操作将会被阻塞
        go Add.TestAddTwo(chs[i])  // 开启协程发送chan
    }

    for _,ch := range (chs) {
        fmt.Println("====================",len(ch)) //当程序运行到这里时,这个channel有可能并没有写入数据,所以长度有可能为0 1 2
        a := <-ch  // 当这里从当前channel读取不到数据时就会阻塞
        // b := <-ch  // 继续读取,读取不到就堵塞
        fmt.Println(a)

        item := chan_time_out_handler(ch)
        fmt.Println(item)

        // 当channel写完数据操作完成后如果没有关闭,读取完数据,chan为空时,将会阻塞,从而有可能造成死锁,所以chan使用完必须关闭

    }

    // 单向channel的实现,当需要将一个单向的channel从读变为写,或者从写变为读时,需要进行类型转换
    // 第一个步,定义一个正常的channel
    ch_normal := make(chan int)
    // 第二步进行类型转换,将ch_normal 转换为只允许写的channel
    var ch_in chan<- int = ch_normal
    go chan_in(ch_in)
    // 第三步 生成一个只允许进行读的channel
    var ch_out  <-chan int = ch_normal
    chan_out(ch_out)
}


// 当向一个channel写入数据,在这个channel被读取前,这个操作是阻塞的(在缓冲区写满之前,即使没有读取操作,写操作都不会阻塞)
// 当从一个channel读取数据时,在对应的channel写入数据前,这个操作也是阻塞的,从而可以利用channel实现了类似锁的功能,进而保证
// 了所有goroutine完成后主函数才返回
// 缓冲区满之后将会阻塞,除非有goroutine对其进行操作,否则协程就会停留在向该channel写入元素的步骤上,直到主进程退出,向channel写入数据的协程也就退出. 协程的阻塞不影响主进程的执行

// 定义一个channel var chanName chan ElementType
// 多层定义,例如定义一个 map,键是string类型,元素是bool类型的channel:  var myMap map[string] chan bool
// 声明以后,定义一个channel 并赋值给变量: map["firstChan"] := make(chan false),使用内建函数make()

// 如果是使用range遍历chan,这是channel中可能仍会存在数据)
// 当多个goroutine都使用了同一个channel时,// 其他goroutine将无法继续对这个channel进行读取,可以在主进程中进行守护,等所有的goroutine执行完毕后再去关闭channel
// close(chan) //关闭一个channel

// 判断一个channel是否已关闭
//1. 如果channel已经关闭,继续往它发送数据会导致panic: send on closed channel
//2. 关闭一个已经关闭的channel也会导致panic: close of closed channel
func test2(ch chan int){
    for{
        if value,ok:=<-ch;ok{
            //do somthing
            fmt.Print(value)
        }else{
            break //ok 为false,表示channel已经被关闭，退出循环
        }
    }
}

// channel关闭后，仍然可以从中读取已发送的数据(使用range无法实现)，读取完数据后，将读取到零值，可以多次读取。
func test1(){
    ch:=make(chan int,3)
    ch<-3
    ch<-2
    ch<-1
    close(ch)
    fmt.Print(<-ch)
    fmt.Print(<-ch)
    fmt.Print(<-ch)
    fmt.Print(<-ch)
    fmt.Print(<-ch)
}