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, 那么当chan关闭时, 读取操作会立即结束,跳出循环(注意,这是channel中可能仍会存在数据)
// 当多个goroutine都使用了同一个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)
}