Go语言备注2

defer 表示后续的调用defer fmt.Println(1)defer fmt.Println(2)//输出的是2, 1//最后的小括号表示调用某函数// 表示匿名函数func() {    fmt.Println(1)}()defer func() {    fmt.Println(1)}()func B(){    //defer 需要放在panic之前，然后有panic的话，就能将程序recover过来    defer func(){        if err := recover(); err!=nil{            fmt.Println("a");        }    }()    panic("panic in b")}

panic/recover(只能在defer里面调用)

1.1 struct 类似结构体

type person struct {    Name string    Age int}func main(){    a:=person{} //引用是大括号    a.Name = "j"    a.Age = 19    b:=person{        Name: "joe",        Age: 19    } //引用是大括号    //加个取地址符号，然后赋值的时候，不用加* ,这样b就是取地址    b:= &person{        Name: "joe",        Age: 19    } //引用是大括号    b.Name = "aa"    b:= &struct {        Name string        Age int    }{        Name: "joe",        Age: 19    } //匿名结构}

赋值只是值的拷贝，这样在函数里面修改后，外面的还是维持原样，如果需要的话，就用指针的形式来传递地址。

并发concurrency

很多人都是冲着 Go 大肆宣扬的高并发而忍不住跃跃欲试，但其实从
源码的解析来看，goroutine 只是由官方实现的超级“线程池”而已。
不过话说回来，每个实例 4-5KB 的栈内存占用和由于实现机制而大幅
减少的创建和销毁开销，是制造 Go 号称的高并发的根本原因。另外，
goroutine 的简单易用，也在语言层面上给予了开发者巨大的便利。

并发不是并行：Concurrency Is Not Parallelism
并发主要由切换时间片来实现“同时”运行，在并行则是直接利用
多核实现多线程的运行，但 Go 可以设置使用核数，以发挥多核计算机
的能力。

Goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

最简单的使用方式，用go关键字运行goroutine ，通过通信来实行内存分配

package mainimport (    "fmt"    "time")func main() {    go Go() //goroutine    time.Sleep(2 * time.Second)}func Go() {    fmt.Println("Go Go Go")}

Channel

Channel 是 goroutine 沟通的桥梁，大都是阻塞同步的
通过 make 创建，close 关闭
Channel 是引用类型
可以使用 for range 来迭代不断操作 channel
可以设置单向或双向通道
可以设置缓存大小，在未被填满前不会发生阻塞

Select

可处理一个或多个 channel 的发送与接收
同时有多个可用的 channel时按随机顺序处理
可用空的 select 来阻塞 main 函数
可设置超时

package mainimport (    "fmt")func main() {    c := make(chan bool)    go func() {        fmt.Println("Go Go Go")        c <- true  //将true放入c的channel    }()    <-c //表示取出c，知道c的channel有值才会结束，不然会一直等待}func Go() {    fmt.Println("Go Go Go")}

for range的使用

for v := range c {        fmt.Println(v)    }package mainimport (    "fmt")func main() {    c := make(chan bool) //直接make的话是双向通道    c := make(chan bool,1) //表示有缓存，就要先输入，后输出，    go func() {        fmt.Println("Go Go Go")        c <- true        close(c) //关闭c的channel    }()    for v := range c {        fmt.Println(v)    }}

运行十个进程的

package mainimport (    "fmt"    "runtime")func main() {    runtime.GOMAXPROCS(runtime.NumCPU()) //确定cup的核数    c := make(chan bool, 10)             //设置一个缓存长度为10的channel    for i := 0; i < 10; i++ {        go Go(c, i)    }    for i := 0; i < 10; i++ {        <-c    }}func Go(c chan bool, index int) {    a := 1    for i := 0; i < 1000000; i++ {        a += i    }    fmt.Println(index, a)    c <- true}//用sync实现，先增加十个，然后在主线程Wait，次线程Done，关闭10次，然后程序就会关闭，这个和上面那种方式类似，这个是同步包，需要传递指针，这样才能改变数据，不然只是单纯的值复制package mainimport (    "fmt"    "runtime"    "sync" //同步)func main() {    runtime.GOMAXPROCS(runtime.NumCPU()) //确定cup的核数    wg := sync.WaitGroup{}    wg.Add(10)    for i := 0; i < 10; i++ {        go Go(&wg, i)    }    wg.Wait()}func Go(wg *sync.WaitGroup, index int) {    a := 1    for i := 0; i < 1000000; i++ {        a += i    }    fmt.Println(index, a)    wg.Done()}

select的使用方式

// You can edit this code!// Click here and start typing.package mainimport (    "fmt")func main() {    c1, c2 := make(chan int), make(chan string)    o := make(chan bool)    go func() {        a, b := false, false        for {            select {            case v, ok := <-c1:                if !ok {                    if !a {                        o <- true                        a = true                    }                    break                }                fmt.Println("c1", v)            case v, ok := <-c2:                if !ok {                    if !b {                        o <- true                        a = true                    }                    break                }                fmt.Println("c2", v)            }        }    }()    c1 <- 1    c2 <- "hu"    c1 <- 3    c2 <- "aaaa"    close(c1)    close(c2)    for i := 0; i < 2; i++ {        <-o    }}