Golang笔记

春哥大魔王的博客 · · 624 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

静态编译

编译时一个将源代码翻译成低级语言的过程。编译过程比较慢,在设计Go时,编译速度是主要的设计目标之一。静态类型意味着变量必须指定一个类型,如整形,字符串,布尔,数组等,可以在声明变量时指定变量类型,大多数情况下,让编译器自动去推断变量类型。

垃圾回收

变量有一个确定的生命周期。例如函数中定义的局部变量,当函数退出时变量就不存在了。语言的垃圾回收机制可以记录不在使用的变量,然后释放他们占用的内存。垃圾回收机制带来一些性能影响。

代码运行

go run命令会先编译然后再运行你的代码,会在一个临时目录下编译这段代码,然后执行,最后自动清除生成的临时文件。如果只是编译代码可以使用go build。

变量赋值

第一种方式:

var power int
power = 9000

第二种方式:

var power int = 9000

第三种方式:用于声明一个变量并给变量赋值,go可以推断变量类型,在第一次声明变量时,使用:=,此时确定了变量类型。但随后对于此变量的赋值,使用=。

power := 9000

gg := getPower()

func getPower() int{
    return 9001
}

第四种方式:go支持多个变量同事赋值

name, power := "Goku", 9000

函数声明

函数支持多值返回

没有返回值:

func log(message string){
}

一个返回值:

func add (a int, b int) int{
}

两个返回值: func power(name string)(int,bool){ } 多个返回值的场景使用比较多,如果只想获得返回值中的某个值,可以将另一个返回赋值给_:

_, exists:=power("goku")

if exists == false{
}

_是一个空白标识符,多用在返回值时没有真正的赋值,无论返回值是什么类型。

如果函数的参数都是相同的类型,可以简洁的定义:

func add(a,b int) int{
}

结构体

go 不像面向对象语言,没有对象和继承的概念。因此也没有很多面向对象的语言的特征比如多态和重载。 go提供了结构体,如:

type Sanya struct{
    Name string
    Province int
}

通过简单的方式创建一个结构体值类型:

goku := Sanya{
    Name : "sanya",
    Province :23,
}

注意上面结构体结尾的逗号是不能省的。 当不需要给结构体设置任何值甚至任何字段:

goku := Sanya{}

goku := Sanya{Name:"sanya"}
goku.Province = 23

也可以省略字段的名字:

goku := Sanya{"sanya",23}

大多数情况,我们不希望变量直接关联一个值,而是希望一个指针指向变量的值,因为在go语言中,函数的参数传递都是按拷贝传递。指针是一个内存地址。通过指针可以找到这个变量的实际的值,是一种间接的取值。

func main(){
    goku := &Sanya{"sanya",9000}
    Super(goku)
    fm.Println(goku.Power)
}

func Super(s *Sanya){
    s.Power = 10000
}

结果是10000,这样就是传递了指针。复制一个指针变量的开销比复制一个复制复杂的结构体小。

构造函数

结构体没有构造函数,你可以创建一个函数返回一个相应类型的实例来代替:

func NewSanya(name string, province int) Sanya{
    return Sanya{
        Name:name,
        Province:province,
    }
}

为新创建的对象分配内存:

goku := &Sanya{
    name:"goku",
    province:23
}

对已定义对结构体进行扩展:

type Sanya struct{
    Name string
    Province int
    Father *Sanya
}

初始化:

gohan := &Sanya{
    Name:"Sanya",
    Province:23,
    Father:&Sanya{
        Name:"Haiko",
        Province:23,
        Father:nil,
    }
}

指针类型和值类型

当你写go代码时,很自然就会问自己,这里应该使用值类型还是指针类型。如果你不确定时,就使用指针。值传递是一种确保数据不可变对方法。有时候需要函数内对调用代码进行改变,需要使用指针。 即使你不打算改变数据,也要考虑大结构体拷贝的开销,如果小的结构体可以进行拷贝。

数组

数组是固定大小的。声明数组时必须指定他们的大小,一旦数组大小被指定,他就不能扩展变大。

var scores [10]int
scores[0] = 300

// 直接初始化一个有值的数组
scores := [4]int{9001,9002,9003,9004}

// 遍历数组
for index,value:= range scores{
}

数组效率高但是不灵活,我们处理数据时,一般不知道元素的数量,因此使用切片。

切片

在go中你一般很少使用数组。会更多使用切片。切片是一个轻量级的结构体封装,这个结构体被封装后,代表一个数组的一部分。 创建切片时和创建数组不同的是,不需要指定大小。

scores := []int{1,2,3,4}

scores := make([]int,0,10) //长度为0但是容量为10的分片
scores := append(scores,5)

哈希表

定义键值对,可以通过make创建:

lookup := make(map[stirng]int)
lookup["goku"] = 9001

包管理

如果你已经装来git,执行如下命令:

go get github.com/mattn/go-sqlite3 go get将得到这些远程文件并将他们保存在你的工作空间。导入包到工作空间:

import(
    "github.com/mattn/go-sqlite3"
)

接口

接口是一种类型,他只定义了声明,没有具体实现。如:

type Logger interface{
    Log(message string)
}

接口可以在代码中实现解耦。

Go中Buffer高效拼接字符串及自定义线程安全Buffer:

Go中可以使用“+”合并字符串,但这种方式效率非常低,每合并一次,都创建一个新的字符串,就必须遍历复制一次字符串。可以通过Buffer高效拼接字符串。 使用bytes.Buffer来组装字符串,不需要复制,只需要将添加字符串放在缓存末尾即可。由于Buffer中的write和read函数中都未发现锁的踪影,所以Buffer的并非是不安全的。

Go特有的并发编程模型方式:

Goroutine & Channel;

协程Goroutine

在Go世界里,每一个并发执行的活动称为goroutine。 通过goroutine,可以实现并行运算,十分便捷。 go协程类似于一个线程,但是协程由go自身调度,不是系统。在协程中对代码可以和其他代码并发执行。

func main(){
    fmt.Println("start")
    go process()
    time.Sleep(time.Millisecond * 10)
    fmt.Println("done")
}

func process(){
    fmt.Println("processing")
}

我们如何启动一个协程对。只是简单对将go关键字附在要执行对函数前面即可。 go协程很容易创建且开销极小。最终多个go协程将会在同一个底层系统线程上运行。这也是常称为M:N线程模型,因为我们有M个应用协程运行在N个系统线程上。结果就是,一个go协程对开销和系统线程比起来相对低(一般都是几十K)。在现代硬件上,可以跑成千上万对协程。 还隐藏了映射和调度的复杂性。并发执行让go自己去处理。主线程在退出前不会等待所有的协程执行完毕,所以主线程在退出前,协程才有机会执行,所以我们必须让代码协同。

Go高并发Http请求

目标:能够处理从上百万个端点发来的大量POST请求。HTTP请求处理函数会收到包含很多payloads的JSON文档。这些payloads需要被写到Amazon S3上,接着有map-reduce系统来处理。

我们通常会将请求放入队列,通过一定数量(例如通过核心CPU数)goroutine组成一个worker pool,worker pool中的worker读取队列执行任务,最理想的情况下,CPU的所有核都会并行的执行任务。

然后设置两个集群,一个用作处理HTTP请求,一个用作workers。这样可以根据处理后台的工作量进行扩容。

主Goroutine做了什么?

  • 启动系统检测器;

  • 设定通用配置,检查运行环境;

  • 创建定时垃圾回收器;

  • 执行main包的init函数;

  • 执行main包的main函数;

  • 进行一些善后处理工作;

同步

创建一个协程没有难度,启动很多协程开销也不大。但是并发执行的代码需要协同。为了解决这个问题,go提供了管道(channels)。 协程会将代码函数拆分为很多汇编指令,在并发场景下,如果想安全的操作一个变量,唯一的手段就是读取该变量。可以任意多的读,但写必须同步。可以依赖于cpu架构的真正原子操作。更多时候使用一个互斥锁。

//定义锁
lock sync.Mutex

//使用锁
lock.Lock()

//开锁
defer lock.Unlock()

Channel

并发编程的挑战在于数据共享。如果你的go协程没有共享数据,就不需要担心她们。但是现实场景中常常需要多个请求共享数据。通道用于go协程之间传递数据,go协程可以通过通道,传递数据到另一个go协程。结果就是任何时候只有一个go协程可以访问数据。

  • 即通道类型,Go的预定义类型之一。
  • 类型化,并发安全的通用型管道。
  • 用于在多个Goroutine之间传递数据。
  • 以通讯的方式共享内存的最直接体现。

Channel的Happens before原则:

发送操作开始->值拷贝(产生副本)->发送操作结束->接收操作开始->接收方持有值->接收操作结束。 Channel可以协调多个Goroutine的运行。

通道也有类型,就是将要在通道传递到数据的类型,如创建一个通道,这个通道可以用来传递一个整数:

c := make(chan int)

// 将这个通道传递给一个函数
fun worker(c chan int){
}

//通道发送数据
CHANNEL <- DATA

//通道接收数据
VAR := <-CHANNEL

尖头指向的方向是数据的流动方向。 当我们从一个通道接收或向通道发送数据时会阻塞,直到有数据。

定义一个数据处理者结构体:

type Worker struct{
    id int
}

fun (w Worker) process(c chan int){
    for{
        data := <-c
        fat.Pringtf("worker data",w.id)
    }
}

我们的worker很简单,会一直等待数据,直到数据可用,然后处理它,他在一个循环中,永远尽职的等待更多的数据并处理。

启动多个worker:

c := make(chan int)
for i:=0; I<4; I++{
    worker := Worker{id:i}
    go worker.process(c)
}

创建一些任务:

for{
    c <- rand.Int()
    time.Sleep(time.Millisecond*50)
}

我们不知道哪个worker将获得数据。但go可以确保往一个通道发送数据时,仅一个单独的接收器可以接收。通道提供了所有的同步代码。

本文来自:开源中国博客

感谢作者:春哥大魔王的博客

查看原文:Golang笔记

入群交流(和以上内容无关):Go中文网 QQ 交流群:798786647 或加微信入微信群:274768166 备注:入群;关注公众号:Go语言中文网

624 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传