Golang笔记
静态编译
编译时一个将源代码翻译成低级语言的过程。编译过程比较慢，在设计Go时，编译速度是主要的设计目标之一。静态类型意味着变量必须指定一个类型，如整形，字符串，布尔，数组等，可以在声明变量时指定变量类型，大多数情况下，让编译器自动去推断变量类型。
垃圾回收
变量有一个确定的生命周期。例如函数中定义的局部变量，当函数退出时变量就不存在了。语言的垃圾回收机制可以记录不在使用的变量，然后释放他们占用的内存。垃圾回收机制带来一些性能影响。
代码运行
go run命令会先编译然后再运行你的代码，会在一个临时目录下编译这段代码，然后执行，最后自动清除生成的临时文件。如果只是编译代码可以使用go build。
变量赋值
第一种方式：
var power intpower = 9000第二种方式：
var power int = 9000第三种方式：用于声明一个变量并给变量赋值，go可以推断变量类型，在第一次声明变量时，使用:=，此时确定了变量类型。但随后对于此变量的赋值，使用=。
power := 9000gg := 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]intscores[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可以确保往一个通道发送数据时，仅一个单独的接收器可以接收。通道提供了所有的同步代码。
© 著作权归作者所有