Go语言介绍

以下介绍内容 借鉴于 图灵社区图书

 

 

提起Go语言的出身，我们就必须将我们饱含敬意的眼光投向持续推出惊世骇俗成果的贝尔

实验室。贝尔实验室已经走出了多位诺贝尔奖获得者，一些对于现在科技至关重要的研究成果，

比如晶体管、通信技术、数码相机的感光元件CCD和光电池等都源自贝尔实验室。该实验室在科

技界的地位可想而之，是一个毫无争议的科研圣地。

这里我们重点介绍一下贝尔实验室中一个叫计算科学研究中心的部门对于操作系统和编程

语言的贡献。回溯至1969年（估计大部分读者那时候都还没出世），肯·汤普逊（Ken Thompson）

和丹尼斯·里奇（Dennis Ritchie）在贝尔实验室的计算科学研究中心里开发出了Unix这个大名鼎

鼎的操作系统，还因为开发Unix而衍生出了一门同样赫赫有名的编程语言——C语言。对于很大

一部分人而言，Unix就是操作系统的鼻祖，C语言也是计算机课程中最广泛使用的编程语言。Unix

和C语言在过去的几十年以来已经造就了无数的成功商业故事，比如曾在90年代如日中天的太阳

微系统（Sun MicroSystems），现在正如日中天的苹果的Mac OS X操作系统其实也可以认为是Unix

的一个变种（FreeBSD）。

虽然已经取得了如此巨大的成就，贝尔实验室的这几个人并没有因此而沉浸在光环中止步不

前，他们从20世纪80年代又开始了一个名为Plan 9的操作系统研究项目，目的就是解决Unix中的

一些问题，发展出一个Unix的后续替代系统。在之后的几十年中，该研究项目又演变出了另一个

叫Inferno的项目分支，以及一个名为Limbo的编程语言。

Limbo是用于开发运行在小型计算机上的分布式应用的编程语言，它支持模块化编程，编译

期和运行时的强类型检查，进程内基于具有类型的通信通道，原子性垃圾收集和简单的抽象数据

类型。它被设计为：即便是在没有硬件内存保护的小型设备上，也能安全运行。

Limbo语言被认为是Go语言的前身，不仅仅因为是同一批人设计的语言，而是Go语言确实从

Limbo语言中继承了众多优秀的特性。

贝尔实验室后来经历了多次的动荡，包括肯·汤普逊在内的Plan 9项目原班人马加入了

 

 

Google。在Google，他们创造了Go语言。早在2007年9月，Go语言还是这帮大牛的20%自由时间

的实验项目。幸运的是，到了2008年5月，Google发现了Go语言的巨大潜力，从而开始全力支持

这个项目，让这批人可以全身心投入Go语言的设计和开发工作中。Go语言的第一个版本在2009

年11月正式对外发布，并在此后的两年内快速迭代，发展迅猛。第一个正式版本的Go语言于2012

年3月28日正式发布，让Go语言迎来了第一个引人瞩目的里程碑。

基于Google对开源的一贯拥抱态度， Go语言也自然而然地选择了开源方式发布，并使用BSD

授权协议。任何人可以查看Go语言的所有源代码，并可以为Go语言发展而奉献自己的力量。

Google作为Go语言的主推者，并没有简简单单地把语言推给开源社区了事，它不仅组建了一

个独立的小组全职开发Go语言，还在自家的服务中逐步增加对Go语言的支持，比如对于Google

有战略意义的云计算平台GAE（Google AppEngine）很早就开始支持Go语言了。按目前的发展态

势，在Google内部，Go语言有逐渐取代Java和Python主流地位的趋势。在Google的更多产品中，

我们将看到Go语言的踪影，比如Google最核心的搜索和广告业务。

在本书的序中，我们已经清晰诠释了为什么在语言泛滥的时代Google还要设计和推出一门新

的编程语言。按照已经发布的Go语言的特性，我们有足够的理由相信Google推出此门新编程语言

绝不仅仅是简单的跑马圈地运动，而是为了解决切实的问题。

下面我们再来看看Go语言的主要作者。

 肯·汤普逊（Ken Thompson，http://en.wikipedia.org/wiki/Ken_Thompson）：设计了B语言

和C语言，创建了Unix和Plan 9操作系统，1983年图灵奖得主，Go语言的共同作者。

 罗布·派克（Rob Pike，http://en.wikipedia.org/wiki/Rob_Pike）：Unix小组的成员，参与Plan

9和Inferno操作系统，参与 Limbo和Go语言的研发，《Unix编程环境》作者之一。

 罗伯特·格里泽默（Robert Griesemer）：曾协助制作Java的HotSpot编译器和Chrome浏览

器的JavaScript引擎V8。

 拉斯·考克斯（Russ Cox，http://swtch.com/~rsc/）：参与Plan 9操作系统的开发，Google Code

Search项目负责人。

 伊安·泰勒（Ian Lance Taylor）：GCC社区的活跃人物，gold连接器和GCC过程间优化LTO

的主要设计者，Zembu公司的创始人。

 布拉德·菲茨帕特里克（Brad Fitzpatrick，http://en.wikipedia.org/wiki/Brad_Fitzpatrick）：

LiveJournal的创始人，著名开源项目memcached的作者。

虽然我们这里只列出了一部分，大家已经可以看出这个语言开发团队空前强大，这让我们在

为Go语言的优秀特性而兴奋之外，还非常看好这门语言的发展前景。

1.2 语言特性

Go语言作为一门全新的静态类型开发语言，与当前的开发语言相比具备众多令人兴奋不已

的新特性。本书从第2章开始，我们将对Go语言的各个方面进行详细解析，让读者能够尽量轻松

地掌握这门简洁、有趣却又超级强大的新语言。

这里先给读者罗列一下Go语言最主要的特性：

 自动垃圾回收

 更丰富的内置类型

 函数多返回值

 错误处理

 匿名函数和闭包

 类型和接口

 并发编程

 反射

 语言交互性

1.2.1 自动垃圾回收

我们可以先看下不支持垃圾回收的语言的资源管理方式，以下为一小段C语言代码：

void foo()

{

char* p = new char[128];

... // 对p指向的内存块进行赋值

func1(p); // 使用内存指针

delete[] p;

}

各种非预期的原因，比如由于开发者的疏忽导致最后的delete语句没有被调用，都会引发

经典而恼人的内存泄露问题。假如该函数被调用得非常频繁，那么我们观察该进程执行时，会发

现该进程所占用的内存会一直疯长，直至占用所有系统内存并导致程序崩溃，而如果泄露的是系

统资源的话，那么后果还会更加严重，最终很有可能导致系统崩溃。

手动管理内存的另外一个问题就是由于指针的到处传递而无法确定何时可以释放该指针所

指向的内存块。假如代码中某个位置释放了内存，而另一些地方还在使用指向这块内存的指针，

那么这些指针就变成了所谓的“野指针”（wild pointer）或者“悬空指针”（dangling pointer），对

这些指针进行的任何读写操作都会导致不可预料的后果。

由于其杰出的效率，C和C++语言在非常长的时间内都作为服务端系统的主要开发语言，比

如Apache、Nginx和MySQL等著名的服务器端软件就是用C和C++开发的。然而，内存和资源管

理一直是一个让人非常抓狂的难题。服务器的崩溃十有八九就是因为不正确的内存和资源管理导

致，更讨厌的是这种内存和资源管理问题即使被发现了，也很难定位到具体的错误地点，导致无

数程序员通宵达旦地调试程序。

这个问题在多年里被不同人用不同的方式来试图解决，并诞生了一些非常著名的内存检查工

具，比如Rational Purify、Compuware BoundsChecker和英特尔的Parallel Inspector等。从设计方法的

角度也衍生了类似于内存引用计数之类的方法（通常被称为“智能指针”），后续在Windows平台

上标准化的COM出现的一个重要原因就是为了解决内存管理的难题。但是事实证明，这些工具和

 

方法虽然能够在一定程度上辅助开发者，但并没法让开发者避免通宵调试这样又苦又累的工作。

到目前为止，内存泄露的最佳解决方案是在语言级别引入自动垃圾回收算法（Garbage

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

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

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

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

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

自动垃圾回收在C/C++社区一直作为一柄双刃剑看待，虽然到C++0x（后命名为C++11）正

式发布时，这个呼声颇高的特性总算是被加入了，但按C++之父的说法，由于C++本身过于强大，

导致在C++中支持垃圾收集变成了一个困难的工作。假如C++支持垃圾收集，以下的代码片段在

运行时就会是一个严峻的考验：

int* p = new int;

p += 10; // 对指针进行了偏移，因此那块内存不再被引用

// …… 这里可能会发生针对这块int内存的垃圾收集 ……

p -= 10; // 咦，居然又偏移到原来的位置

*p = 10; // 如果有垃圾收集，这里就无法保证可以正常运行了

微软的C++/CLI算是用一种偏门的方式让C++程序员们有机会品尝一下垃圾回收功能的鲜美

味道。在C/C++之后出现的新语言，比如Java和C#等，基本上都已经自带自动垃圾回收功能。

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

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

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

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

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

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

1.2.2 更丰富的内置类型

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

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

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

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

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

院派气息迥然不同。

另外有一个新增的数据类型：数组切片（Slice）。我们可以认为数组切片是一种可动态增

长的数组。这几种数据结构基本上覆盖了绝大部分的应用场景。数组切片的功能与C++标准库中

的vector非常类似。Go语言在语言层面对数组切片的支持，相比C++开发者有效地消除了反复

写以下几行代码的工作量：

#include <vector>

#include <map>

#include <algorithm>

using namespace std;

因为是语言内置特性，开发者根本不用费事去添加依赖的包，既可以少一些输入工作量，也

可以让代码看起来尽量简洁。

1.2.3 函数多返回值

目前的主流语言中除Python外基本都不支持函数的多返回值功能，不是没有这类需求，可能

是语言设计者没有想好该如何提供这个功能，或者认为这个功能会影响语言的美感。

比如我们如果要定义一个函数用于返回个人名字信息，而名字信息因为包含多个部分——姓

氏、名字、中间名和别名，在不支持多返回值的语言中我们有以下两种做法：要么专门定义一个

结构体用于返回，比如：

struct name

{

char first_name[20];

char middle_name[20];

char last_name[20];

char nick_name[48];

};

// 函数原型

extern name get_name();

// 函数调用

name n = get_name();

或者以传出参数的方式返回多个结果：

// 函数原型

extern void get_name(

/*out*/char* first_name,

/*out*/char* middle_name,

/*out*/char* last_name,

/*out*/char* nick_name);

// 先分配内存

char first_name[20];

char middle_name[20];

char last_name[20];

char nick_name[48];

// 函数调用

get_name(first_name, middle_name, last_name, nick_name);

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

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

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

 

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

func getName()(firstName, middleName, lastName, nickName string){

return "May", "M", "Chen", "Babe"

}

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

而提供了极大的灵活性：

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()

我们会在第2章中详细讲解多重返回值的用法。

1.2.4 错误处理

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

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

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

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

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

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

1.2.5 匿名函数和闭包

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

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

递和调用：

f := func(x, y int) int {

return x + y

}

1.2.6 类型和接口

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

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

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

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

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

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

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

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

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

// 抽象接口

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语言的接口体系则避免了这类问题：

type Bird struct {

...

}

func (b *Bird) Fly() {

// 以鸟的方式飞行

}

 

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

接口：

type IFly interface {

Fly()

}

这两者目前看起来完全没有关系，现在看看我们如何使用它们：

func main() {

var fly IFly = new(Bird)

fly.Fly()

}

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

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

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

1.2.7 并发编程

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包提供了完备的读写锁功能。

下面我们用一个简单的例子来演示goroutine和channel的使用方式。这是一个并行计算的例

子，由两个goroutine进行并行的累加计算，待这两个计算过程都完成后打印计算结果，具体如代

码清单1-1所示。

 

代码清单1-1 paracalc.go

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)

}

1.2.8 反射

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

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

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

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

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

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

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

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

依赖于反射功能来实现。

这里先举一个小例子，可以利用反射功能列出某个类型中所有成员变量的值，如代码清单1-2

所示。

代码清单1-2 reflect.go

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())

}

}

该程序的输出结果为：

0: Name string = Sparrow

1: LifeExpectance int = 3

我们会在第9章中简要介绍反射的基本使用方法和注意事项。

1.2.9 语言交互性

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

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

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

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

边界是如何跨越的。

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

准库的puts函数。

代码清单1-3 cprint.go

package main

/*

#include <stdio.h>

*/

import "C"

import "unsafe"

func main() {

cstr := C.CString("Hello, world")

C.puts(cstr)

C.free(unsafe.Pointer(cstr))

}