Golang语言特性

好久没有更新博客了,前段时间博主一个再找实习,所以一直没有更新自己的博客,以后会坚持每周一篇2016年刚开始,博主就给自己制定了一个学习计划,学习golang ,至于为什么学习golang呢,这篇文章就是博主学习golang的原因就是因为他的特性,博主是看这本《Go语言编程》学习Golang的,Go语言编程

[code]Go语言最主要的特性：
自动垃圾回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

1,Golang自动回收机制

Go语言作为一门新生的开发语言，当然不能忽略内存管理这个问题。又因为Go语言没有C++

这么“强大”的指针计算功能，因此可以很自然地包含垃圾回收功能。因为垃圾回收功能的支持，

开发者无需担心所指向的对象失效的问题，因此Go语言中不需要delete关键字，也不需要free()

方法来明确释放内存。例如，对于以上的这个C语言例子，如果使用Go语言实现，我们就完全不

用考虑何时需要释放之前分配的内存的问题，系统会自动帮我们判断，并在合适的时候（比如CPU

相对空闲的时候）进行自动垃圾收集工作。

非常著名的内存检查工具，比如Rational Purify、 Compuware BoundsChecker和英特尔的Parallel Inspector等

垃圾回收，即所有的内存分配动作都会被在运行时记录，同时任何对

该内存的使用也都会被记录，然后垃圾回收器会对所有已经分配的内存进行跟踪监测，一旦发现

有些内存已经不再被任何人使用，就阶段性地回收这些没人用的内存。当然，因为需要尽量最小

化垃圾回收的性能损耗，以及降低对正常程序执行过程的影响，现实中的垃圾回收算法要比这个

复杂得多，比如为对象增加年龄属性等，但基本原理都是如此。

Go语言作为一门新生的开发语言，当然不能忽略内存管理这个问题。又因为Go语言没有C++

这么“强大”的指针计算功能，因此可以很自然地包含垃圾回收功能。因为垃圾回收功能的支持，

开发者无需担心所指向的对象失效的问题，因此Go语言中不需要delete关键字，也不需要free()

方法来明确释放内存。例如，对于以上的这个C语言例子，如果使用Go语言实现，我们就完全不

用考虑何时需要释放之前分配的内存的问题，系统会自动帮我们判断，并在合适的时候（比如CPU

相对空闲的时候）进行自动垃圾收集工作。

2,GO更丰富的内置类型

除了几乎所有语言都支持的简单内置类型（比如整型和浮点型等）外， Go语言也内置了一

些比较新的语言中内置的高级类型，比如C#和Java中的数组和字符串。除此之外， Go语言还内置

了一个对于其他静态类型语言通常用库方式支持的字典类型（map）。 Go语言设计者对为什么内

置map这个问题的回答也颇为简单：既然绝大多数开发者都需要用到这个类型，为什么还非要每

个人都写一行import语句来包含一个库？这也是一个典型的实战派观点，与很多其他语言的学

院派气息迥然不同。

3Go函数多返回值

函数多返回值

Go语言革命性地在静态开发语言阵营中率先提供了多返回值功能。这个特性让开发者可以

从原来用各种比较别扭的方式返回多个值的痛苦中解脱出来，既不用再区分参数列表中哪几个用

于输入，哪几个用于输出，也不用再只为了返回多个值而专门定义一个数据结构。

在Go语言中，上述的例子可以修改为以下的样子：

[code]func getName()(firstName, middleName, lastName, nickName string){
return "May", "M", "Chen", "Babe"
}

因为返回值都已经有名字，因此各个返回值也可以用如下方式来在不同的位置进行赋值，从

而提供了极大的灵活性：

[code]func getName()(firstName, middleName, lastName, nickName string){
firstName = "May"
middleName = "M"
lastName = "Chen"
nickName = "Babe"
return
}

并不是每一个返回值都必须赋值，没有被明确赋值的返回值将保持默认的空值。而函数的调

用相比C/C++语言要简化很多：

fn, mn, ln, nn := getName()

如果开发者只对该函数其中的某几个返回值感兴趣的话，也可以直接用下划线作为占位符来

忽略其他不关心的返回值。下面的调用表示调用者只希望接收lastName的值，这样可以避免声

明完全没用的变量：

, , lastName, _ := getName()

4,Go的错误处理

Go语言引入了3个关键字用于标准的错误处理流程，这3个关键字分别为defer、 panic和

recover。本书的“序”已经用示例展示了defer关键字的强大之处，在第2章中我们还会详细

描述Go语言错误处理机制的独特之处。整体上而言与C++和Java等语言中的异常捕获机制相比，

Go语言的错误处理机制可以大量减少代码量，让开发者也无需仅仅为了程序安全性而添加大量

一层套一层的try-catch语句。这对于代码的阅读者和维护者来说也是一件很好的事情，因为可

以避免在层层的代码嵌套中定位业务代码。 2.6节将介绍Go语言中的错误处理机制。

5,Go的匿名函数和闭包

在Go语言中，所有的函数也是值类型，可以作为参数传递。 Go语言支持常规的匿名函数和

闭包，比如下列代码就定义了一个名为f的匿名函数，开发者可以随意对该匿名函数变量进行传

递和调用：

[code]f := func(x, y int) int {
return x + y
}

6,Go类型和接口

Go语言的类型定义非常接近于C语言中的结构（struct），甚至直接沿用了struct关键字。相

比而言， Go语言并没有直接沿袭C++和Java的传统去设计一个超级复杂的类型系统，不支持继承

和重载，而只是支持了最基本的类型组合功能。

巧妙的是，虽然看起来支持的功能过于简洁，细用起来你却会发现， C++和Java使用那些复

杂的类型系统实现的功能在Go语言中并不会出现无法表现的情况，这反而让人反思其他语言中

引入这些复杂概念的必要性。我们在第3章中将详细描述Go语言的类型系统。

Go语言也不是简单的对面向对象开发语言做减法，它还引入了一个无比强大的“非侵入式”

接口的概念，让开发者从以往对C++和Java开发中的接口管理问题中解脱出来。在C++中，我们

通常会这样来确定接口和类型的关系：

[code]// 抽象接口
interface IFly
{
virtual void Fly()=0;
};
// 实现类
class Bird : public IFly
{
public:
Bird()
{}
virtual ~Bird()
{}
public:
void Fly()
{
// 以鸟的方式飞行
}
};
void main()
{
IFly* pFly = new Bird();
pFly->Fly();
delete pFly;
}

显然，在实现一个接口之前必须先定义该接口，并且将类型和接口紧密绑定，即接口的修改

会影响到所有实现了该接口的类型，而Go语言的接口体系则避免了这类问题：

[code]type Bird struct {
...
}
func (b *Bird) Fly() {
// 以鸟的方式飞行
}

我们在实现Bird类型时完全没有任何IFly的信息。我们可以在另外一个地方定义这个IFly

接口：

[code]type IFly interface {
Fly()
}
这两者目前看起来完全没有关系，现在看看我们如何使用它们：
func main() {
var fly IFly = new(Bird)
fly.Fly()
}

可以看出，虽然Bird类型实现的时候，没有声明与接口IFly的关系，但接口和类型可以直

接转换，甚至接口的定义都不用在类型定义之前，这种比较松散的对应关系可以大幅降低因为接

口调整而导致的大量代码调整工作。

7,Go 并发编程

Go语言引入了goroutine概念，它使得并发编程变得非常简单。通过使用goroutine而不是裸用

操作系统的并发机制，以及使用消息传递来共享内存而不是使用共享内存来通信， Go语言让并

发编程变得更加轻盈和安全。

通过在函数调用前使用关键字go，我们即可让该函数以goroutine方式执行。 goroutine是一种

比线程更加轻盈、更省资源的协程。 Go语言通过系统的线程来多路派遣这些函数的执行，使得

每个用go关键字执行的函数可以运行成为一个单位协程。当一个协程阻塞的时候，调度器就会自

动把其他协程安排到另外的线程中去执行，从而实现了程序无等待并行化运行。而且调度的开销

非常小，一颗CPU调度的规模不下于每秒百万次，这使得我们能够创建大量的goroutine，从而可

以很轻松地编写高并发程序，达到我们想要的目的。

Go语言实现了CSP（通信顺序进程， Communicating Sequential Process）模型来作为goroutine

间的推荐通信方式。在CSP模型中，一个并发系统由若干并行运行的顺序进程组成，每个进程不

能对其他进程的变量赋值。进程之间只能通过一对通信原语实现协作。 Go语言用channel（通道）

这个概念来轻巧地实现了CSP模型。 channel的使用方式比较接近Unix系统中的管道（pipe）概念，

可以方便地进行跨goroutine的通信。

另外，由于一个进程内创建的所有goroutine运行在同一个内存地址空间中，因此如果不同的

goroutine不得不去访问共享的内存变量，访问前应该先获取相应的读写锁。 Go语言标准库中的

sync包提供了完备的读写锁功能。

示例代码:

[code]package main
import "fmt"
func sum(values [] int, resultChan chan int) {
sum := 0
for _, value := range values {
sum += value
}
resultChan <- sum // 将计算结果发送到channel中
}
func main() {
values := [] int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
resultChan := make(chan int, 2)
go sum(values[:len(values)/2], resultChan)
go sum(values[len(values)/2:], resultChan)
sum1, sum2 := <-resultChan, <-resultChan // 接收结果
fmt.Println("Result:", sum1, sum2, sum1 + sum2)
}

8,Go的 反射

反射（reflection）是在Java语言出现后迅速流行起来的一种概念。通过反射，你可以获取对

象类型的详细信息，并可动态操作对象。反射是把双刃剑，功能强大但代码可读性并不理想。若

非必要，我们并不推荐使用反射。

Go语言的反射实现了反射的大部分功能，但没有像Java语言那样内置类型工厂，故而无法做

到像Java那样通过类型字符串创建对象实例。在Java中，你可以读取配置并根据类型名称创建对

应的类型，这是一种常见的编程手法，但在Go语言中这并不被推荐。

反射最常见的使用场景是做对象的序列化（serialization，有时候也叫Marshal & Unmarshal）。

例如， Go语言标准库的encoding/json、 encoding/xml、 encoding/gob、 encoding/binary等包就大量

依赖于反射功能来实现。

[code]package main
import (
"fmt"
"reflect"
)
type Bird struct {
Name string
LifeExpectance int
}
func (b *Bird) Fly() {
fmt.Println("I am flying...")
}
func main() {
sparrow := &Bird{"Sparrow", 3}
s := reflect.ValueOf(sparrow).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
fmt.Printf("%d: %s %s = %v\n", i, typeOfT.Field(i).Name, f.Type(),
f.Interface())
}
}

9,GO语言交互性

由于Go语言与C语言之间的天生联系， Go语言的设计者们自然不会忽略如何重用现有C模块

的这个问题，这个功能直接被命名为Cgo。 Cgo既是语言特性，同时也是一个工具的名称。

在Go代码中，可以按Cgo的特定语法混合编写C语言代码，然后Cgo工具可以将这些混合的C

代码提取并生成对于C功能的调用包装代码。开发者基本上可以完全忽略这个Go语言和C语言的

边界是如何跨越的。

与Java中的JNI不同， Cgo的用法非常简单，比如代码清单1-3就可以实现在Go中调用C语言标

准库的puts函数。

package main

[code]/*
#include <stdio.h>
*/
import "C"
import "unsafe"
func main() {
cstr := C.CString("Hello, world")
C.puts(cstr)
C.free(unsafe.Pointer(cstr))
}