Go语言编程入门超级指南
1.序言
Golang作为一门出身名门望族的编程语言新星，像豆瓣的Redis平台Codis、类Evernote的云笔记leanote等。
1.1 为什么要学习
如果有人说X语言比Y语言好，两方的支持者经常会激烈地争吵。如果你是某种语言老手，你就是那门语言的“传道者”，下意识地会保护它。无论承认与否，你都已被困在一个隧道里，你看到的完全是局限的。《肖申克的救赎》对此有很好的注脚：
[Red] These walls are funny. First you hate ‘em, then you get used to ‘em. Enough time passes, you get so you depend on them. That's institutionalized.聽
这些墙很有趣。起初你恨它们，之后你习惯了它们。随着时间流逝，你开始以来它们。这就是体制。
在你还没有被完全“体制化”时，为何不多学些语言，哪怕只是浅尝辄止，潜移默化中也许你的思维壁垒就松动了。不管是Golang还是Ruby还是其他语言，当看到一些语法习惯与之前熟悉的C和Java不同时，的确潜意识里就会产生抵触情绪，觉得这不好，还是自己习惯的那套好。长此以往，如果不能冲破自己的心理，“坐以待毙”，被时间淘汰恐怕只是早晚的事儿。所以这里的关键也 不是非要学习Golang，而是要不断地学！
1.2 用什么工具来开发
Golang也有专门的IDE，但由于最近迷上了Sublime Text神器，所以这里还是用ST来学习Golang。配置步骤与在ST中使用其他语言开发都类似：
安装智能提示插件GoSublime
创建编译配置脚本
点Preferences -> Package Settings -> GoSublime -> User Settings中写入（感觉保存时自动格式化出来的缩进、空格等风格有些“讨厌”，所以就禁掉了）：
复制代码代码如下:
{
聽聽聽 "fmt_enabled": false,
聽聽聽 "env": {聽聽聽聽
聽聽聽聽聽聽聽 "path":"D:\\Program Files (x86)\\Go\bin"
聽聽聽 }
}
点新建Build System产生go.sublime-build中写入：
{
聽聽聽 "path": "D:\\Program Files (x86)\\Go\\bin",
聽聽聽 "cmd": ["go", "run", "${file}"],
聽聽聽 "selector": "source.go"
}
2.你好，世界
Golang版的HelloWorld来了！一眼望去，package和import的声明方式与Java如出一辙，比较明显的区别是：func关键字、每行末尾没有分号、Println()大写的函数名。这个例子虽小，却“五脏俱全”，后面会逐一分析这个小例子中碰到的Golang语法点。
复制代码代码如下:
package main
import "fmt"
func main() {
聽聽聽 fmt.Println("你好，世界！")
}
2.1 运行方式
Golang提供了go run“解释”执行和go build编译执行两种运行方式，所谓的“解释”执行其实也是编译出了可执行文件后才执行的。
复制代码代码如下:
$ go run helloworld.go
你好，世界！
复制代码代码如下:
$ go build helloworld.go
$ ls
helloworld聽 helloworld.go
复制代码代码如下:
$ ./helloworld
你好，世界！
2.2 Package管理
上面例子中我们使用的就是fmt包下的Println()函数。Golang约定：我们可以用./或../相对路径来引自己的package；如果不是相对路径，那么go会去$GOPATH/src下查找。
2.3 格式化输出
类似C、Java等语言，Golang的fmt包提供了格式化输出功能，而且像%d、%s等占位符和\t、\r、\n转义也几乎完全一致。但Golang的Println不支持格式化，只有Printf支持，所以我们经常会在后面加入\n换行。此外，Golang加入了%T打印值的类型，%v打印数组等集合的所有元素。
复制代码代码如下:
package main
import "fmt"
import "math"
/**
聽* This is Printer!
聽* 布尔值：false
聽* 二进制：11111111
聽* 八进制：377
聽* 十六进制：FF
聽* 十进制：255
聽* 浮点数：3.141593
聽* 字符串：printer
聽*
聽* 对象类型：int,string,bool,float64
聽* 集合：[1 2 3 4 5]
聽*/
func main() {
聽聽聽 fmt.Println("This is Printer!")
聽聽聽 fmt.Printf("布尔值：%t\n", 1 == 2)
聽聽聽 fmt.Printf("二进制：%b\n", 255)
聽聽聽 fmt.Printf("八进制：%o\n", 255)
聽聽聽 fmt.Printf("十六进制：%X\n", 255)
聽聽聽 fmt.Printf("十进制：%d\n", 255)
聽聽聽 fmt.Printf("浮点数：%f\n", math.Pi)
聽聽聽 fmt.Printf("字符串：%s\n", "printer")
聽聽聽 fmt.Printf("对象类型：%T,%T,%T,%T\n", 1, "hello", true, math.E)
聽聽聽 fmt.Printf("集合：%v\n", [5]int{1, 2, 3, 4, 5})
}
3.语法基础
3.1 变量和常量
虽然Golang是静态类型语言，却用类似JavaScript中的var关键字声明变量。而且像同样是静态语言的Scala一样，支持类型自动推断。有一点很重要的不同是：如果明确指明变量类型的话，类型要放在变量名后面。这有点别扭吧？！后面会看到函数的入参和返回值的类型也要这样声明。
复制代码代码如下:
package main
import "fmt"
/**
聽* 单变量声明：num[100], word[hello]
聽* 多变量声明：i[1], i[2], k[3]
聽* 推导类型：b1[true], b2[false]
聽* 常量：age[20], pi[3.141593]
聽*/
func main() {
聽聽聽 var num int = 100
聽聽聽 var word string = "hello"
聽聽聽 fmt.Printf("单变量声明：num[%d], word[%s]\n", num, word)
聽聽聽 var i, j, k int = 1, 2, 3
聽聽聽 fmt.Printf("多变量声明：i[%d], i[%d], k[%d]\n", i, j, k)
聽聽聽 var b1 = true
聽聽聽 b2 := false
聽聽聽 fmt.Printf("推导类型：b1[%t], b2[%t]\n", b1, b2)
聽聽聽 const age int = 20
聽聽聽 const pi float32 = 3.1415926
聽聽聽 fmt.Printf("常量：age[%d], pi[%f]\n", age, pi)
}
3.2 控制语句
作为最基本的语法要素，Golang的各种控制语句也是特点鲜明。在对C继承发扬的同时，也有自己的想法融入其中：
if/switch/for的条件部分都没有圆括号，但必须有花括号。
switch的case中不需要break。《C专家编程》里也“控诉”了C的fall-through问题。既然90%以上的情况都要break，为何不将break作为case的默认行为？而且编程语言后来者也鲜有纠正这一问题的。
switch的case条件可以是多个值。
Golang中没有while。
复制代码代码如下:
package main
import "fmt"
/**
聽* testIf: x[2] is even
聽* testIf: x[3] is odd
聽*
聽* testSwitch: One
聽* testSwitch: Two
聽* testSwitch: Three, Four, Five [3]
聽* testSwitch: Three, Four, Five [4]
聽* testSwitch: Three, Four, Five [5]
聽*
聽* 标准模式：[0] [1] [2] [3] [4] [5] [6]聽
聽* While模式：[0] [1] [2] [3] [4] [5] [6]聽
聽* 死循环模式：[0] [1] [2] [3] [4] [5] [6]聽
聽*/
func main() {
聽聽聽 testIf(2)
聽聽聽 testIf(3)
聽聽聽 testSwitch(1)
聽聽聽 testSwitch(2)
聽聽聽 testSwitch(3)
聽聽聽 testSwitch(4)
聽聽聽 testSwitch(5)
聽聽聽 testFor(7)
}
func testIf(x int) {
聽聽聽 if x % 2 == 0 {
聽聽聽聽聽聽聽 fmt.Printf("testIf: x[%d] is even\n", x)
聽聽聽 } else {
聽聽聽聽聽聽聽 fmt.Printf("testIf: x[%d] is odd\n", x)
聽聽聽 }
}
func testSwitch(i int) {
聽聽聽 switch i {
聽聽聽聽聽聽聽 case 1:
聽聽聽聽聽聽聽聽聽聽聽 fmt.Println("testSwitch: One")
聽聽聽聽聽聽聽 case 2:
聽聽聽聽聽聽聽聽聽聽聽 fmt.Println("testSwitch: Two")
聽聽聽聽聽聽聽 case 3, 4, 5:
聽聽聽聽聽聽聽聽聽聽聽 fmt.Printf("testSwitch: Three, Four, Five [%d]\n", i)
聽聽聽聽聽聽聽 default:
聽聽聽聽聽聽聽聽聽聽聽 fmt.Printf("testSwitch: Invalid value[%d]\n", i)
聽聽聽 }
}
func testFor(upper int) {
聽聽聽 fmt.Print("标准模式：")
聽聽聽 for i := 0; i < upper; i++ {
聽聽聽聽聽聽聽 fmt.Printf("[%d] ", i)
聽聽聽 }
聽聽聽 fmt.Println()
聽聽聽 fmt.Print("While模式：")
聽聽聽 j := 0
聽聽聽 for j < upper {
聽聽聽聽聽聽聽 fmt.Printf("[%d] ", j)
聽聽聽聽聽聽聽 j++
聽聽聽 }
聽聽聽 fmt.Println()
聽聽聽 fmt.Print("死循环模式：")
聽聽聽 k := 0
聽聽聽 for {
聽聽聽聽聽聽聽 if (k >= upper) {
聽聽聽聽聽聽聽聽聽聽聽 break
聽聽聽聽聽聽聽 }
聽聽聽聽聽聽聽 fmt.Printf("[%d] ", k)
聽聽聽聽聽聽聽 k++
聽聽聽 }
聽聽聽 fmt.Println()
}
分号和花括号聽
分号由词法分析器在扫描源代码过程自动插入的，分析器使用简单的规则：如果在一个新行前方的最后一个标记是一个标识符（包括像int和float64这样的单词）、一个基本的如数值这样的文字、或break continue fallthrough return ++ – ) }中的一个时，它就会自动插入分号。聽
分号的自动插入规则产生了“蝴蝶效应”：所有控制结构的左花括号不都能放在下一行。因为按照上面的规则，这样做会导致分析器在左花括号的前方插入一个分号，从而引起难以预料的结果。所以Golang中是不能随便换行的。
3.3 函数
函数有几点不同：
func关键字。
最大的不同就是“倒序”的类型声明。
不需要函数原型，引用的函数可以后定义。这一点很好，真不喜欢C语言里要么将“最底层抽象”的函数放在最前面定义，要么写一堆函数原型声明在最前面。
3.4 集合
Golang提供了数组和Map作为基本数据结构：
数组中的元素会自动初始化，例如int数组元素初始化为0
切片（借鉴Python）的区间跟主流语言一样，都是 “左闭右开”
用 range()遍历数组和Map
复制代码代码如下:
package main
import "fmt"
/**
聽* Array未初始化:聽 [0 0 0 0 0]
聽* Array赋值:聽 [0 10 0 20 0]
聽* Array初始化:聽 [0 1 2 3 4 5]
聽* Array二维:聽 [[0 1 2] [1 2 3]]
聽* Array切片： [2 3] [0 1 2 3] [2 3 4 5]
聽*
聽* Map哈希表：map[one:1 two:2 three:3]，长度[3]
聽* Map删除元素后：map[one:1 three:3]，长度[2]
聽* Map打印：
聽*聽 one => 1
聽*聽 four => 4
聽*聽 three => 3
聽*聽 five => 5
聽*/
func main() {
聽聽聽 testArray()
聽聽聽 testMap()
}
func testArray() {
聽聽聽 var a [5]int
聽聽聽 fmt.Println("Array未初始化: ", a)
聽聽聽 a[1] = 10
聽聽聽 a[3] = 20
聽聽聽 fmt.Println("Array赋值: ", a)
聽聽聽 b := []int{0, 1, 2, 3, 4, 5}
聽聽聽 fmt.Println("Array初始化: ", b)
聽聽聽 var c [2][3]int
聽聽聽 for i := 0; i < 2; i++ {
聽聽聽聽聽聽聽 for j := 0; j < 3; j++ {
聽聽聽聽聽聽聽聽聽聽聽 c[i][j] = i + j
聽聽聽聽聽聽聽 }
聽聽聽 }
聽聽聽 fmt.Println("Array二维: ", c)
聽聽聽 d := b[2:4] // b[3,4]
聽聽聽 e := b[:4]聽 // b[1,2,3,4]
聽聽聽 f := b[2:]聽 // b[3,4,5]
聽聽聽 fmt.Println("Array切片：", d, e, f)
}
func testMap() {
聽聽聽 m := make(map[string]int)
聽聽聽 m["one"] = 1
聽聽聽 m["two"] = 2
聽聽聽 m["three"] = 3
聽聽聽 fmt.Printf("Map哈希表：%v，长度[%d]\n", m, len(m))
聽聽聽 delete(m, "two")
聽聽聽 fmt.Printf("Map删除元素后：%v，长度[%d]\n", m, len(m))
聽聽聽 m["four"] = 4
聽聽聽 m["five"] = 5
聽聽聽 fmt.Println("Map打印：")
聽聽聽 for key, val := range m {
聽聽聽聽聽聽聽 fmt.Printf("\t%s => %d\n", key, val)
聽聽聽 }
聽聽聽 fmt.Println()
}
3.5 指针和内存分配
Golang中可以使用指针，并提供了两种内存分配机制：
new：分配长度为0的空白内存，返回类型T*。
make：仅用于 切片、map、chan消息管道，返回类型T而不是指针。
复制代码代码如下:
package main
import "fmt"
/**
聽* 整数i=[10]，指针pInt=[0x184000c0]，指针指向*pInt=[10]
聽* 整数i=[3]，指针pInt=[0x184000c0]，指针指向*pInt=[3]
聽* 整数i=[5]，指针pInt=[0x184000c0]，指针指向*pInt=[5]
聽*聽
聽* Wild的数组指针： <nil>
聽* Wild的数组指针==nil[true]
聽*聽
聽* New分配的数组指针： &[]
聽* New分配的数组指针[0x18443010]，长度[0]
聽* New分配的数组指针==nil[false]
聽* New分配的数组指针Make后： &[0 0 0 0 0 0 0 0 0 0]
聽* New分配的数组元素[3]： 23
聽*聽
聽* Make分配的数组引用： [0 0 0 0 0 0 0 0 0 0]
聽*/
func main() {
聽聽聽 testPointer()
聽聽聽 testMemAllocate()
}
func testPointer() {
聽聽聽 var i int = 10;
聽聽聽 var pInt *int = &i;
聽聽聽 fmt.Printf("整数i=[%d]，指针pInt=[%p]，指针指向*pInt=[%d]\n",
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 i, pInt, *pInt)
聽聽聽 *pInt = 3
聽聽聽 fmt.Printf("整数i=[%d]，指针pInt=[%p]，指针指向*pInt=[%d]\n",
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 i, pInt, *pInt)
聽聽聽 i = 5
聽聽聽 fmt.Printf("整数i=[%d]，指针pInt=[%p]，指针指向*pInt=[%d]\n",
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 i, pInt, *pInt)
}
func testMemAllocate() {
聽聽聽 var pNil *[]int
聽聽聽 fmt.Println("Wild的数组指针：", pNil)
聽聽聽 fmt.Printf("Wild的数组指针==nil[%t]\n", pNil == nil)
聽聽聽 var p *[]int = new([]int)
聽聽聽 fmt.Println("New分配的数组指针：", p)
聽聽聽 fmt.Printf("New分配的数组指针[%p]，长度[%d]\n", p, len(*p))
聽聽聽 fmt.Printf("New分配的数组指针==nil[%t]\n", p == nil)
聽聽聽 //Error occurred
聽聽聽 //(*p)[3] = 23
聽聽聽 *p = make([]int, 10)
聽聽聽 fmt.Println("New分配的数组指针Make后：", p)
聽聽聽 (*p)[3] = 23
聽聽聽 fmt.Println("New分配的数组元素[3]：", (*p)[3])
聽聽聽 var v []int = make([]int, 10)
聽聽聽 fmt.Println("Make分配的数组引用：", v)
}
3.6 面向对象编程
Golang的结构体跟C有几点不同：
结构体可以有方法，其实也就相当于OOP中的类了。
支持带名称的初始化。
用指针访问结构中的属性也用”.”而不是”->”，指针就像Java中的引用一样。
没有public，protected，private等访问权限控制。C也没有protected，C中默认是public的，private需要加static关键字限定。Golang中方法名大写就是public的，小写就是private的。
同时，Golang支持接口和多态，而且接口有别于Java中继承和实现的方式，而是采取了类似Ruby中更为新潮的Duck Type。只要struct与interface有相同的方法，就认为struct实现了这个接口。就好比只要能像鸭子那样叫，我们就认为它是一只鸭子一样。
复制代码代码如下:
package main
import (
聽聽聽 "fmt"
聽聽聽 "math"
)
// -----------------
//聽聽聽聽聽 Struct
// -----------------
type Person struct {
聽聽聽 name聽聽聽 string
聽聽聽 age聽聽聽聽 int
聽聽聽 email聽聽 string
}
func (p *Person) getName() string {
聽聽聽 return p.name
}
// -------------------
//聽聽聽聽聽 Interface
// -------------------
type shape interface {
聽聽聽 area() float64
}
type rect struct {
聽聽聽 width float64
聽聽聽 height float64
}
func (r *rect) area() float64 {
聽聽聽 return r.width * r.height
}
type circle struct {
聽聽聽 radius float64
}
func (c *circle) area() float64 {
聽聽聽 return math.Pi * c.radius * c.radius
}
// -----------------
//聽聽聽聽聽 Test
// -----------------
/**
聽* 结构Person[{cdai 30 cdai@gmail.com}]，姓名[cdai]
聽* 结构Person指针[&{cdai 30 cdai@gmail.com}]，姓名[cdai]
聽* 用指针修改结构Person为[{carter 40 cdai@gmail.com}]
聽*聽
聽* Shape[0]周长为[13.920000]
聽* Shape[1]周长为[58.088048]
聽*/
func main() {
聽聽聽 testStruct()
聽聽聽 testInterface()
}
func testStruct() {
聽聽聽 p1 := Person{"cdai", 30, "cdai@gmail.com"}
聽聽聽 p1 = Person{name: "cdai", age: 30, email: "cdai@gmail.com"}
聽聽聽 fmt.Printf("结构Person[%v]，姓名[%s]\n", p1, p1.getName())
聽聽聽 ptr1 := &p1
聽聽聽 fmt.Printf("结构Person指针[%v]，姓名[%s]\n", ptr1, ptr1.getName())
聽聽聽 ptr1.age = 40
聽聽聽 ptr1.name = "carter"
聽聽聽 fmt.Printf("用指针修改结构Person为[%v]\n", p1)
}
func testInterface() {
聽聽聽 r := rect { width: 2.9, height: 4.8 }
聽聽聽 c := circle { radius: 4.3 }
聽聽聽 s := []shape{ &r, &c }
聽聽聽 for i, sh := range s {
聽聽聽聽聽聽聽 fmt.Printf("Shape[%d]周长为[%f]\n", i, sh.area())
聽聽聽 }
}
3.7 异常处理
Golang中异常的使用比较简单，可以用errors.New创建，也可以实现Error接口的方法来自定义异常类型，同时利用函数的多返回值特性可以返回异常类。比较复杂的是defer和recover关键字的使用。Golang没有采取try-catch“包住”可能出错代码的这种方式，而是用 延迟处理 的方式。
用defer调用的函数会以后进先出（LIFO）的方式，在当前函数结束后依次顺行执行。defer的这一特点正好可以用来处理panic。当panic被调用时，它将立即停止当前函数的执行并开始逐级解开函数堆栈，同时运行所有被defer的函数。如果这种解开达到堆栈的顶端，程序就死亡了。但是，也可以使用内建的recover函数来重新获得Go程的控制权并恢复正常的执行。由于仅在解开期间运行的代码处在被defer的函数之内，recover仅在被延期的函数内部才是有用的。
复制代码代码如下:
package main
import (
聽聽聽 "fmt"
聽聽聽 "errors"
聽聽聽 "os"
)
/**
聽* 自定义Error类型，实现内建Error接口
聽* type Error interface {
聽*聽聽聽聽聽 Error() string
聽* }
聽*/
type MyError struct {
聽聽聽 arg int
聽聽聽 msg string
}
func (e *MyError) Error() string {
聽聽聽 return fmt.Sprintf("%d - %s", e.arg, e.msg)
}
/**
聽* Failed[*errors.errorString]: Bad Arguments - negative!
聽* Success:聽 16
聽* Failed[*main.MyError]: 1000 - Bad Arguments - too large!
聽*聽
聽* Recovered! Panic message[Cannot find specific file]
聽* 4 3 2 1 0
聽*/
func main() {
聽聽聽 // 1.Test error
聽聽聽 args := []int{-1, 4, 1000}
聽聽聽 for _, i := range args {
聽聽聽聽聽聽聽 if r, e := testError(i); e != nil {
聽聽聽聽聽聽聽聽聽聽聽 fmt.Printf("Failed[%T]: %v\n", e, e)
聽聽聽聽聽聽聽 } else {
聽聽聽聽聽聽聽聽聽聽聽 fmt.Println("Success: ", r)
聽聽聽聽聽聽聽 }
聽聽聽 }
聽聽聽 // 2.Test defer
聽聽聽 src, err := os.Open("control.go")
聽聽聽 if (err != nil) {
聽聽聽聽聽聽聽 fmt.Printf("打开文件错误[%v]\n", err)
聽聽聽聽聽聽聽 return
聽聽聽 }
聽聽聽 defer src.Close()
聽聽聽 // use src...
聽聽聽 for i := 0; i < 5; i++ {
聽聽聽聽聽聽聽 defer fmt.Printf("%d ", i)
聽聽聽 }
聽聽聽 // 3.Test panic/recover
聽聽聽 defer func() {
聽聽聽聽聽聽聽 if r := recover(); r != nil {
聽聽聽聽聽聽聽聽聽聽聽 fmt.Printf("Recovered! Panic message[%s]\n", r)
聽聽聽聽聽聽聽 }
聽聽聽 }()
聽聽聽 _, err2 := os.Open("test.go")
聽聽聽 if (err2 != nil) {
聽聽聽聽聽聽聽 panic("Cannot find specific file")
聽聽聽 }
}
func testError(arg int) (int, error) {
聽聽聽 if arg < 0 {
聽聽聽聽聽聽聽 return -1, errors.New("Bad Arguments - negative!")
聽聽聽 } else if arg > 256 {
聽聽聽聽聽聽聽 return -1, &MyError{ arg, "Bad Arguments - too large!" }
聽聽聽 } else {
聽聽聽聽聽聽聽 return arg * arg, nil
聽聽聽 }
}
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的语言就要看有哪些抽象层次更高的特性等等。还是那句话，基础语言只能说我们会用，而能够区别一门语言的高级特性才是它的根本和灵魂，也是我们要着重学习和领悟的地方。
有疑问加站长微信联系（非本文作者）
