Go语言编程

在开始学习编程时，很多人都会遇到这个经典的题目，打印前n个数中的质数。但如何并行解决这个问题呢？

一个直接的思路是，如果我们打印前100个数中的质数，我们直接找100个工人，每个工人计算其中一个数是不是质数，如果是质数则输出该数。虽然这是一个可行的解决方案，但不够优雅。特别是较小数容易判断是否是质数，较大数不容易判断，造成了工人之间负载不平衡。

下面有一段很好的代码展示了如何并行解决这个问题。代码用Go语言实现，这个例子也展示了Go语言的魅力。

这个解决方案的核心思想在于，将判断是否是质数转换为一个流水线任务。假如我们有100个工人，编号从1到100.当需要判断数字29是不是质数时，只需要向1号工人问一下，29能不能被2整除，向2号工人问一下，29能不能被3整除......这样如果前28个工人都回答不能整除，则29就是质数。

上面的计算仍有冗余，可以优化。判断一个数是否是质数，只需要拿比它小的质数除一下，并不需要比它小的所有数。这样我们需要计算2，3，5......的工人，而不需要计算4的工人。

最后一点，工人是个动态增多的过程，当我们判断出一个质数时，才需要新增这个工人。例如，当我们需要判断2，3，4，5，6......是否是质数，我们知道2是质数，则产生一个工人负责计算2，当3来到时，发现3不能被2整除，则产生一个工人负责计算3，以此类推。

下面我们看源码。

func primetask(c chan int) { p := <- c if p > goal { os.Exit(0) } fmt.Println(p) nc := make(chan int) go primetask(nc) for { i := <- c if i % p != 0 { nc <- i } } }

在主函数进行调用时，用以下方式

c := make(chan int) go primetask(c) for i := 2;; i++ { c <- i }

每调用一次primetask时，产生一个工人。第一次在主函数调用go primetask(c)时，这个c就是流水线的输入。先输入2，这时函数内p的值变为2，然后打印输出2，表明2是一个质数。从此以后这个函数负责计算新来的值是不是被2整除。另外这个函数还需要构造和下一个工人的通道，即nc，当这个工人发现新来的数字不能被2整除时，需要通过nc交给下一个工人。每个工人第一次接受到的值（p）是不能被前面所有工人整除的值，即是一个质数，打印输出。之后，每个工人需要检查新来的值是否能被p整除，如果能，则无需发给下一个工人，如果不能，则发给下一个工人。

通过这个小例子可以看到Go语言精妙的地方。一门优秀的语言往往能解放思想，提高生产力。

第1章 初始Go语言 1.1 语言简史 1.2 语言特性 1.2.1 自动垃圾回收（GC） 1.2.2 更丰富的内置类型那个 1.2.3 多返回值 1.2.4 错误处理 1.2.5 匿名函数和闭包 1.2.6 类型和接口 1.2.7 并发编程 1.2.8 反射 1.2.9 语言交互性 1.3 第一个Go程序 1.3.2 编译环境准备 1.3.3 编译程序 1.4 开发工具选择 1.5 工程管理 1.6 问题追踪和调试 1.7 如何寻求帮助 1.7.1 邮件列表 1.7.2 网站资源 第2章 顺序编程 2.1 变量 2.1.1 变量声明 2.1.2 变量初始化 21.3 变量赋值 2.1.4 匿名变量 2.2 常量 2.2.1 字面常量 2.2.2 常量定义 2.2.3 预定义常量 2.2.4 枚举 2.3 类型 2.3.4 复数类型 2.3.5 字符串 2.3.6 字符类型 2.3.8 数组切片 2.3.9 map 2.4 流程控制 2.4.1 条件语句 2.4.2 选择语句 2.4.3 循环语句 2.4.4 跳转语句 2.5 函数 2.5.2 函数调用 2.5.3 不定参数 2.6 错误处理 2.6.2 defer 2.6.3 panic()和recover() 第3章 面向对象编程 3.3 匿名组合 3.5 接口 3.5.7 Any类型 第4章 并发编程 4.3 goroutine 4.5 channel 4.5.1 语法 4.5.2 select 4.5.3 缓冲机制 4.5.4 超时机制 4.5.6 单向channel 4.6 多核并行化 4.8 同步 4.8.1 同步锁 4.8.2 全局唯一性操作 第5章 网络编程 5.3 RPC编程 5.3.1 Go语言中的RPC支持和处理 第6章 安全编程 第7章 工程管理 第8章 开发工具 第9章 进阶话题 9.2 语言交互性 9.2.1 类型映射 9.5 接口机理 9.5.2 接口查询 附录A A.1 Go语言标准卡

第1章 初始Go语言

1.1 语言简史

1.2 语言特性

1.2.1 自动垃圾回收（GC）

1.2.2 更丰富的内置类型那个

1.2.3 多返回值

1.2.4 错误处理

• 关键字：defer，panic，recover

1.2.5 匿名函数和闭包

1.2.6 类型和接口

1.2.7 并发编程

1.2.8 反射

reflection

1.2.9 语言交互性

Cgo

1.3 第一个Go程序

1.3.2 编译环境准备

1.3.3 编译程序

1.4 开发工具选择

• Lite IDE，一款专为Go语言开发的继承开发环境

1.5 工程管理

用目录结构和包名

如下的一个工程结构：

<calcproj> ├─<src> ├─<calc> ├─calc.go ├─<simplemath> ├─add.go ├─add_test.go ├─sqrt.go ├─sqrt_test.go ├─<bin> ├─<pkg>＃包将被安装到此处

编译的时候需要设置环境变量GOPATH，增加calcproj的目录进去

另外，源代码有错误：args = os.Args改成args = os.Args[1:]

1.6 问题追踪和调试

1.7 如何寻求帮助

1.7.1 邮件列表

• http://groups.google.com/group/golang-nuts
• http://groups.google.com/group/golang-china
• http://groups.google.com/group/ecug

1.7.2 网站资源

• http://golang.org

第2章 顺序编程

2.1 变量

2.1.1 变量声明

关键字：var 可以有下面这种写法：

var ( v1 int v2 string )

2.1.2 变量初始化

21.3 变量赋值

多重赋值：

i, j = j, i

2.1.4 匿名变量

2.2 常量

2.2.1 字面常量

2.2.2 常量定义

关键字：const

2.2.3 预定义常量

• true, false和iota
• iota iota在每一次const出现的时候置为0，后面每出现一次iota加1
• 如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式

2.2.4 枚举

const( Sunday = iota Monday Tuesday Wednesday Thursday Friday Saturday numberOfDays // 这个常量没有导出 )

2.3 类型

2.3.4 复数类型

• real()和imag()获取实部和虚部

2.3.5 字符串

字符串初始化后不能被修改，这点和数组不一样

2.3.6 字符类型

• byte： UTF-8字符串的单个字符的值
• rune：单个Unicode字符

2.3.8 数组切片

将一个数组切片追加到另一个数组切片

mySlice2 := []int{8, 9, 10} // 给mySlice后面添加另一个数组切片 mySlice = append(mySlice, mySlice2...)

注意：数组切pain后面跟了省略号…

• 内容复制:copy函数复制切片

2.3.9 map

2.4 流程控制

2.4.1 条件语句

• 在有返回值的函数中，不允许将“最终的”return语句包含在if … else … 结构中，否则会编译失败：

function ends without a returnstatement。

2.4.2 选择语句

• 明确使用关键字：fallthrough，才会继续执行紧跟的下一个case

2.4.3 循环语句

Go语言不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方式来初始化多个变量。

2.4.4 跳转语句

• gogo

2.5 函数

2.5.2 函数调用

规则：小写字母开头的函数只在本包内可见，大写字母开头的函数才能被其他包使用。

2.5.3 不定参数

语法糖（syntactic sugar）

funcmyfunc(args ...int) { for_, arg := rangeargs { fmt.Println(arg) } }

• 原理 类型…type就是数组切片
• 任意类型的不定参数 用interface{}传递任意类型数据是Go语言的惯例用法。

funcPrintf(format string, args ...interface{}) { // ... }

2.6 错误处理

2.6.2 defer

defer语句的调用是遵照先进后出的原则，即最后一个defer语句将最先被执行。

2.6.3 panic()和recover()

第3章 面向对象编程

3.3 匿名组合

官网《Effective Go》

3.5 接口

3.5.7 Any类型

空接口：interface{}

第4章 并发编程

4.3 goroutine

关于打印没出来的问题解释：Go程序从初始化main package并执行main()函数开始，当main()函数返回时，程序退出，且程序并不等待其他goroutine（非主goroutine）结束。

4.5 channel

• 关键字：chan

4.5.1 语法

var chanName chan ElementType

阻塞：

• 向channel写入数据通常会导致程序阻塞，直到有其他goroutine从这个channel中读取数据。
• 如果channel之前没有写入数据，那么从channel中读取数据也会导致程序阻塞，直到channel中被写入数据为止

4.5.2 select

限制：

• 每个case语句里必须是一个IO操作

4.5.3 缓冲机制

c := make(chan int, 1024)

4.5.4 超时机制

用select实现

4.5.6 单向channel

varch1 chan int // ch1是一个正常的channel，不是单向的 varch2 chan<- float64// ch2是单向channel，只用于写float64数据 varch3 <-chan int // ch3是单向channel，只用于读取int数据

4.6 多核并行化

4.8 同步

4.8.1 同步锁

• 关键字：sync.Mutex和sync.RWMutex

4.8.2 全局唯一性操作

• 关键字：sync.Once

第5章 网络编程

5.3 RPC编程

5.3.1 Go语言中的RPC支持和处理

一个RPC 服务端可以注册多个不同类型的对象，但不允许注册同一类型的多个对象。

func(t *T) MethodName(argType T1, replyType *T2) error

第6章 安全编程

第7章 工程管理

第8章 开发工具

第9章 进阶话题

9.2 语言交互性

9.2.1 类型映射

在跨语言交互中，比较复杂的问题有两个：类型映射以及跨越调用边界传递指针所带来的对象生命周期和内存管理的问题。

9.5 接口机理

9.5.2 接口查询

var reader IReader = NewReader() if writer, ok := reader.(IReadWriter); ok { writer.Write() }

附录A

A.1 Go语言标准卡

可以当手册使用啊