作者： 一字马胡
转载标志 【2017-11-22】

更新日志

日期	更新内容	备注
2017-11-22	新建文章	go语言入门学习笔记（二）

golang入门学习笔记系列

• golang入门学习笔记（一）

interface for golang

interface是一组方法的集合，这些方法只是被声明，没有具体的实现。下面是一个关于interface的例子：

package main
import "fmt"
import "math"

type geometry interface {
    area() float64
    perim() float64
}


type rect struct {
    width, height float64
}

type circle struct {
    radius float64
}


func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}


func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}


func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}
    
     measure(r)
    measure(c)
}

在golang中，如果想要实现一个interface，只需要实现这个Interface中的所有方法就可以了，对于上面提到的这个例子，首先我们的Interface中声明了两个方法，然后对于rect和circle都实现了这两个方法，所以对于任意rect和circle的实例都可以调用这个Interface中声明的两个方法。怎么感觉这是泛型呢？

Goroutines for golang

A goroutine is a lightweight thread of execution.
Suppose we have a function call f(s). Here’s how
we’d call that in the usual way, running it synchronously.
To invoke this function in a goroutine, use go f(s).
This new goroutine will execute concurrently with the calling one.

go语言天生就是为高并发设计的，内置支持并发，goroutines是非常轻量级的实现并发的go组件，它不是thread，这一点需要特别注意，系统运行时可以有几万个goroutines，goroutines拥有可以自行管理的调用栈，总之是非常轻量级的，下面展示了goroutines的使用方法：

func compute(t int) {

    fmt.Print("start to compute...\n")

    var tt time.Duration

    if t == 0 {
        tt = time.Duration(rand.Intn(2)) * time.Second;
    } else {
        tt = time.Duration(t) * time.Second
    }
    //sleep to mock...
    time.Sleep(tt)

    fmt.Print("compute done.\n")
}

func main() {

    go compute(1)

    //wait the go function
    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
}

使用Goroutines只需要在普通的方法调用前面加上go关键字就可以了，加上go关键字之后，我们的方法就会在一个新的Goroutines中执行，所以为了看到结果需要等待一下Goroutines执行结束，否则看不到任何输出。

Channels for golang

Channels are the pipes that connect concurrent goroutines.
You can send values into channels from one goroutine and
receive those values into another goroutine.

Channels是将多个goroutines联系起来的关键组件，可以通过使用make(chan type)来创建一个Channel，下面是一个使用Channel的例子：

func channel(n int, c chan  string)  {
    if n == 0 {
        n = rand.Intn(10)
    }

    fmt.Print("n:", n, "\n")

    str := "channel-"

    for i := 0; i < n; i ++ {
        c <- fmt.Sprintf("#%d %s %d", i, str, i)
    }
}



func main() {

    n := 3
    c := make(chan string)
    go channel(n, c)

    for i := 0; i < n; i ++ {
        fmt.Printf("check : %d -> %s\n", i, <-c)
    }
}

Channel将两个方法联系起来并且进行同步，在main方法中，c会在通道的一端等待直到有数据写入，这个过程是阻塞的，所以在这个例子里面我们不需要做额外的等待操作就可以看到结果。Channel类似一个管道，一端写，一端接收数据，并且很有意思的是箭头的方向代表了数据的流向。

When using channels as function parameters, you can specify
if a channel is meant to only send or receive values. This
specificity increases the type-safety of the program.

有时候这也是需要被支持的，下面是一个例子：

func ping(pings chan<- string, msg string) {
    pings <- msg
}

func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}


func main() {

    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}   

上面的例子非常有趣，有两个函数，首先对于ping函数来说，它有一个Channel参数，并且将这个Channel限定为只允许发送数据，而第二个函数pong中有两个Channel参数，pings参数限定为只允许发送数据，而pongs参数只允许接收数据，两个函数结合起来使用，可以达到数据ping-pong的效果。字符串“passed message”首先会到pings中，然后pings将数据传到msg，msg又将数据传到pongs中。如果把pong函数改成下面：

func pong(pings <-chan string, pongs chan<- string) {
    //msg := <-pings
    pongs <- pings
}

则再次运行就会出现下面的错误：

cannot use pings (type <-chan string) as type string in send

因为对于pong函数来说，pings 这个Channel只允许接收来自Channel的数据而不允许向Channel发送数据。关于如何区别一个Channel的数据流向，可以这样理解，chan关键字是目标Channel，箭头总是指向当前Channel，所以，对于发送，写成:chan<-，对于接收，写成<-chan。