Java程序员的Golang入门指南(下)

4.高级特性

上面介绍的只是Golang的基本语法和特性，尽管像控制语句的条件不用圆括号、函数多返回值、switch-case默认break、函数闭包、集合切片等特性相比Java的确提高了开发效率，但这些在其他语言中也都有，并不是Golang能真正吸引人的地方。不仅是Golang，我们学习任何语言当然都是从基本语法特性着手，但学习时要不断地问自己：使这门语言区别于其他语言的”独到之处“在哪？这种独到之处往往反映了语言的设计思想、出发点、要解决的”痛点“，这才是一门语言或任何技术的立足之本。

4.1 goroutine

goroutine使用go关键字来调用函数，也可以使用匿名函数。可以简单的把go关键字调用的函数想像成pthread_create。如果一个goroutine没有被阻塞，那么别的goroutine就不会得到执行。也就是说goroutine阻塞时，Golang会切换到其他goroutine执行，这是非常好的特性！Java对类似goroutine这种的协程没有原生支持，像Akka最害怕的就是阻塞。因为协程不等同于线程，操作系统不会帮我们完成“现场”保存和恢复，所以要实现goroutine这种特性，就要模拟操作系统的行为，保存方法或函数在协程“上下文切换”时的Context，当阻塞结束时才能正确地切换回来。像Kilim等协程库利用字节码生成，能够胜任，而Akka完全是运行时的。

注意：如果你要真正的并发，需要调用runtime.GOMAXPROCS(CPU_NUM)设置。

package main

import "fmt"

func main() {

    go f("goroutine")

    go func(msg string) {

        fmt.Println(msg)

    }("going")

    // Block main thread

    var input string

    fmt.Scanln(&input)

    fmt.Println("done")

}

func f(msg string) {

    fmt.Println(msg)

}

4.2 原子操作

像Java一样，Golang支持很多CAS操作。运行结果是unsaftCnt可能小于200，因为unsafeCnt++在机器指令层面上不是一条指令，而可能是从内存加载数据到寄存器、执行自增运算、保存寄存器中计算结果到内存这三部分，所以不进行保护的话有些更新是会丢失的。

package main

import (

    "fmt"

    "time"

    "sync/atomic"

    "runtime"

)

func main() {

    // IMPORTANT!!!

    runtime.GOMAXPROCS(4)

    // thread-unsafe

    var unsafeCnt int32 = 0

    for i := 0; i < 10; i++ {

        go func() {

            for i := 0; i < 20; i++ {

                time.Sleep(time.Millisecond)

                unsafeCnt++

            }

        }()

    }

    time.Sleep(time.Second)

    fmt.Println("cnt: ", unsafeCnt)

    // CAS toolkit

    var cnt int32 = 0

    for i := 0; i < 10; i++ {

        go func() {

            for i := 0; i < 20; i++ {

                time.Sleep(time.Millisecond)

                atomic.AddInt32(&cnt, 1)

            }

        }()

    }

    time.Sleep(time.Second)

    cntFinal := atomic.LoadInt32(&cnt)

    fmt.Println("cnt: ", cntFinal)

}

神奇CAS的原理

Golang的AddInt32()类似于Java中AtomicInteger.incrementAndGet()，其伪代码可以表示如下。二者的基本思想是一致的，本质上是 乐观锁：首先，从内存位置M加载要修改的数据到寄存器A中；然后，修改数据并保存到另一寄存器B；最终，利用CPU提供的CAS指令（Java通过JNI调用到）用一条指令完成：1）A值与M处的原值比较；2）若相同则将B值覆盖到M处。

若不相同，则CAS指令会失败，说明从内存加载到执行CAS指令这一小段时间内，发生了上下文切换，执行了其他线程的代码修改了M处的变量值。那么重新执行前面几个步骤再次尝试。

ABA问题：即另一线程修改了M位置的数据，但是从原值改为C，又从C改回原值。这样上下文切换回来，CAS指令发现M处的值“未改变”（实际是改了两次，最后改回来了），所以CAS指令正常执行，不会失败。这种问题在Java中可以用AtomicStampedReference/AtomicMarkableReference解决。

public final int incrementAndGet() {

    for (;;) {

        int current = get();

        int next = current + 1;

        if (compareAndSet(current, next))

            return next;

    }

}

4.3 Channel管道

通过前面可以看到，尽管goroutine很方便很高效，但如果滥用的话很可能会导致并发安全问题。而Channel就是用来解决这个问题的，它是goroutine之间通信的桥梁，类似Actor模型中每个Actor的mailbox。多个goroutine要修改一个状态时，可以将请求都发送到一个Channel里，然后由一个goroutine负责顺序地修改状态。

Channel默认是阻塞的，也就是说select时如果没有事件，那么当前goroutine会发生读阻塞。同理，Channel是有大小的，当Channel满了时，发送方会发生写阻塞。Channel这种阻塞的特性加上goroutine可以很容易就能实现生产者-消费者模式。

用case可以给Channel设置阻塞的超时时间，避免一直阻塞。而default则使select进入无阻塞模式。

package main

import (

    "fmt"

    "time"

)

/**

 * Output:

 * received message: hello

 * received message: world

 *

 * received from channel-1: Hello

 * received from channel-2: World

 *

 * received message: hello

 * Time out!

 *

 * Nothing received!

 * received message: hello

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * Nothing received!

 * received message: world

 * Nothing received!

 * Nothing received!

 * Nothing received!

 */

func main() {

    listenOnChannel()

    selectTwoChannels()

    blockChannelWithTimeout()

    unblockChannel()

}

func listenOnChannel() {

    // Specify channel type and buffer size

    channel := make(chan string, 5)

    go func() {

        channel <- "hello"

        channel <- "world"

    }()

    for i := 0; i < 2; i++ {

        msg := <- channel

        fmt.Println("received message: " + msg)

    }

}

func selectTwoChannels() {

    c1 := make(chan string)

    c2 := make(chan string)

    go func() {

        time.Sleep(time.Second)

        c1 <- "Hello"

    }()

    go func() {

        time.Sleep(time.Second)

        c2 <- "World"

    }()

    for i := 0; i < 2; i++ {

        select {

            case msg1 := <- c1:

                fmt.Println("received from channel-1: " + msg1)

            case msg2 := <- c2:

                fmt.Println("received from channel-2: " + msg2)

        }

    }

}

func blockChannelWithTimeout() {

    channel := make(chan string, 5)

    go func() {

        channel <- "hello"

        // Sleep 10 sec

        time.Sleep(time.Second * 10)

        channel <- "world"

    }()

    for i := 0; i < 2; i++ {

        select {

            case msg := <- channel:

                fmt.Println("received message: " + msg)

            // Set timeout 5 sec

            case <- time.After(time.Second * 5):

                fmt.Println("Time out!")

        }

    }

}

func unblockChannel() {

    channel := make(chan string, 5)

    go func() {

        channel <- "hello"

        time.Sleep(time.Second * 10)

        channel <- "world"

    }()

    for i := 0; i < 15; i++ {

        select {

            case msg := <- channel:

                fmt.Println("received message: " + msg)

            default:

                fmt.Println("Nothing received!")

                time.Sleep(time.Second)

        }

    }

}

4.4 缓冲流

Golang的bufio包提供了方便的缓冲流操作，通过strings或网络IO得到流后，用bufio.NewReader/Writer()包装：

• 缓冲区：Peek()或Read时，数据会从底层进入到缓冲区。缓冲区默认大小为4096字节。
• 切片和拷贝：Peek()和ReadSlice()得到的都是切片（缓冲区数据的引用）而不是拷贝，所以更加节约空间。但是当缓冲区数据变化时，切片也会随之变化。而ReadBytes/String()得到的都是数据的拷贝，可以放心使用。
• Unicode支持：ReadRune()可以直接读取Unicode字符。有意思的是Golang中Unicode字符也要用单引号，这点与Java不同。
• 分隔符：ReadSlice/Bytes/String()得到的包含分隔符，bufio不会自动去掉。
• Writer：对应地，Writer提供了WriteBytes/String/Rune。
• undo方法：可以将读出的字节再放回到缓冲区，就像什么都没发生一样。

package main

import (

    "fmt"

    "strings"

    "bytes"

    "bufio"

)

/**

 * Buffered: 0

 * Buffered after peek: 7

 * ABCDE

 * AxCDE

 *

 * abcdefghijklmnopqrst 20 <nil>

 * uvwxyz1234567890     16 <nil>

 *                      0  EOF

 *

 * "ABC "

 * "DEF "

 * "GHI"

 *

 * "ABC "

 * "DEF "

 * "GHI"

 *

 * read unicode=[你], size=[3]

 * read unicode=[好], size=[3]

 * read(after undo) unicode=[好], size=[3]

 *

 * Available: 4096

 * Buffered: 0

 * Available after write: 4088

 * Buffered after write: 8

 * Buffer after write: ""

 * Available after flush: 4096

 * Buffered after flush: 0

 * Buffer after flush: "ABCDEFGH"

 *

 * Hello,世界！

 */

func main() {

    testPeek()

    testRead()

    testReadSlice()

    testReadBytes()

    testReadUnicode()

    testWrite()

    testWriteByte()

}

func testPeek() {

    r := strings.NewReader("ABCDEFG")

    br := bufio.NewReader(r)

    fmt.Printf("Buffered: %d\n", br.Buffered())

    p, _ := br.Peek(5)

    fmt.Printf("Buffered after peek: %d\n", br.Buffered())

    fmt.Printf("%s\n", p)

    p[1] = 'x'

    p, _ = br.Peek(5)

    fmt.Printf("%s\n", p)

}

func testRead() {

    r := strings.NewReader("abcdefghijklmnopqrstuvwxyz1234567890")

    br := bufio.NewReader(r)

    b := make([]byte, 20)

    n, err := br.Read(b)

    fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

    n, err = br.Read(b)

    fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

    n, err = br.Read(b)

    fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

}

func testReadSlice() {

    r := strings.NewReader("ABC DEF GHI")

    br := bufio.NewReader(r)

    w, _ := br.ReadSlice(' ')

    fmt.Printf("%q\n", w)

    w, _ = br.ReadSlice(' ')

    fmt.Printf("%q\n", w)

    w, _ = br.ReadSlice(' ')

    fmt.Printf("%q\n", w)

}

func testReadBytes() {

    r := strings.NewReader("ABC DEF GHI")

    br := bufio.NewReader(r)

    w, _ := br.ReadBytes(' ')

    fmt.Printf("%q\n", w)

    w, _ = br.ReadSlice(' ')

    fmt.Printf("%q\n", w)

    s, _ := br.ReadString(' ')

    fmt.Printf("%q\n", s)

}

func testReadUnicode() {

    r := strings.NewReader("你好，世界！")

    br := bufio.NewReader(r)

    c, size, _ := br.ReadRune()

    fmt.Printf("read unicode=[%c], size=[%v]\n", c, size)

    c, size, _ = br.ReadRune()

    fmt.Printf("read unicode=[%c], size=[%v]\n", c, size)

    br.UnreadRune()

    c, size, _ = br.ReadRune()

    fmt.Printf("read(after undo) unicode=[%c], size=[%v]\n", c, size)

}

func testWrite() {

    b := bytes.NewBuffer(make([]byte, 0))

    bw := bufio.NewWriter(b)

    fmt.Printf("Available: %d\n", bw.Available())

    fmt.Printf("Buffered: %d\n", bw.Buffered())

    bw.WriteString("ABCDEFGH")

    fmt.Printf("Available after write: %d\n", bw.Available())

    fmt.Printf("Buffered after write: %d\n", bw.Buffered())

    fmt.Printf("Buffer after write: %q\n", b)

    bw.Flush()

    fmt.Printf("Available after flush: %d\n", bw.Available())

    fmt.Printf("Buffered after flush: %d\n", bw.Buffered())

    fmt.Printf("Buffer after flush: %q\n", b)

}

func testWriteByte() {

    b := bytes.NewBuffer(make([]byte, 0))

    bw := bufio.NewWriter(b)

    bw.WriteByte('H')

    bw.WriteByte('e')

    bw.WriteByte('l')

    bw.WriteByte('l')

    bw.WriteByte('o')

    bw.WriteString(",")

    bw.WriteRune('世')

    bw.WriteRune('界')

    bw.WriteRune('！')

    bw.Flush()

    fmt.Println(b)

}

4.5 并发控制

sync包中的WaitGroup是个很有用的类，类似信号量。wg.Add()和Done()能够加减WaitGroup（信号量）的值，而Wait()会挂起当前线程直到信号量变为0。下面的例子用WaitGroup的值表示正在运行的goroutine数量。在goroutine中，用defer Done()确保goroutine正常或异常退出时，WaitGroup都能减一。

package main

import (

    "fmt"

    "sync"

)

/**

 * I'm waiting all goroutines on wg done

 * I'm done=[0]

 * I'm done=[1]

 * I'm done=[2]

 * I'm done=[3]

 * I'm done=[4]

 * I'm done=[5]

 * I'm done=[6]

 * I'm done=[7]

 * I'm done=[8]

 * I'm done=[9]

 */

func main() {

    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {

        wg.Add(1)

        go func(id int) {

            defer wg.Done()

            fmt.Printf("I'm done=[%d]\n", id)

        }(i)

    }

    fmt.Println("I'm waiting all goroutines on wg done")

    wg.Wait()

}

4.6 网络编程

Golang的net包的抽象层次还是挺高的，用不了几行代码就能实现一个简单的TCP或HTTP服务端了。

4.6.1 Socket编程

package main

import (

    "net"

    "fmt"

    "io"

)

/**

 * Starting the server

 * Accept the connection:  127.0.0.1:14071

 * Warning: End of data EOF

 */

func main() {

    listener, err := net.Listen("tcp", "127.0.0.1:12345")

    if err != nil {

        panic("error listen: " + err.Error())

    }

    fmt.Println("Starting the server")

    for {

        conn, err := listener.Accept()

        if err != nil {

            panic("error accept: " + err.Error())

        }

        fmt.Println("Accept the connection: ", conn.RemoteAddr())

        go echoServer(conn)

    }

}

func echoServer(conn net.Conn) {

    buf := make([]byte, 1024)

    defer conn.Close()

    for {

        n, err := conn.Read(buf)

        switch err {

            case nil:

                conn.Write(buf[0:n])

            case io.EOF:

                fmt.Printf("Warning: End of data %s\n", err)

                return

            default:

                fmt.Printf("Error: read data %s\n", err)

                return

        }

    }

}

4.6.2 Http服务器

package main

import (

    "fmt"

    "log"

    "net/http"

)

func main() {

    http.HandleFunc("/hello", handleHello)

    fmt.Println("serving on http://localhost:7777/hello")

    log.Fatal(http.ListenAndServe("localhost:7777", nil))

}

func handleHello(w http.ResponseWriter, req *http.Request) {

    log.Println("serving", req.URL)

    fmt.Fprintln(w, "Hello, world!")

}

5.结束语

5.1 Golang初体验

Golang的某些语法的确很简洁，像行尾无分号、条件语句无括号、类型推断、函数多返回值、异常处理、原生协程支持、DuckType继承等，尽管很多并不是Golang首创，但结合到一起写起来还是很舒服的。

当然Golang也有让人“不爽”的地方。像变量和函数中的类型声明写在后面简直是“反人类”！同样是颠覆，switch的case默认会break就很实用。另外，因为Golang主要还是想替代C做系统开发，所以像类啊、包啊还是能看到C的影子，例如类声明只有成员变量而不会包含方法实现等，支持全局函数等，所以有时看到aaa.bbb()还是有点迷糊，不知道aaa是包名还是实例名。

5.2 如何学习一门语言

当我们谈到学习英语时，想到的可能是背单词、学语法、练习听说读写。对于编程语言来说，背单词（关键字）、学语法（语法规则）少不了，可听说读写只剩下了“写”，因为我们说话的对象是“冷冰冰”的计算机。所以唯一的捷径就是“写”，不断地练习！

此外，学的语言多了也能总结出一些规律。首先是基础语法，包括了变量和常量、控制语句、函数、集合、OOP、异常处理、控制台输入输出、包管理等。然后是高级特性就差别比较大了。专注高并发的语言就要看并发方面的特性，专注OOP的语言就要看有哪些抽象层次更高的特性等等。还是那句话，基础语言只能说我们会用，而能够区别一门语言的高级特性才是它的根本和灵魂，也是我们要着重学习和领悟的地方。