9213510d065039fe29e6c11c5d00748a.png
去年学了一遍 Golang，发现都给整忘了， 好饭不怕晚，再次二刷。 其实学好 Golang 并不难，关键是要找到它和其它语言不同和众里寻他千百度相通的微妙之处，就能很优雅地使用 Golang，以下会涉及较多知识点。

特殊类型

struct{}struct{}{}
interface{}

会自动执行的函数

fun init(){}  // 会自动执行
  • init 函数先于 main 函数自动执行，不能被其他函数调用；
  • init 函数没有输入参数、返回值；
  • 每个包可以有多个 init 函数；
  • 包的每个源文件也可以有多个 init 函数，这点比较特殊；
  • 同一个包的 init 执行顺序，golang 没有明确定义，编程时要注意程序不要依赖这个执行顺序。
  • 不同包的 init 函数按照包导入的依赖关系决定执行顺序。

匿名函数

1: 需要传递匿名函数的地方：

 once.Do(func() { // 该函数只会执行一次
  fmt.Println("Create Obj")
  singleInstance = new(Singleton)
 })

2: 如果一个函数需要返回一个匿名函数:

type retFunc func()  // 通过 type 创建一个  别名

func xxx() retFunc{
 return func(){
  return 1;
 }
}

更凶残的匿名函数:

 writeDataFn := func() {
  var data []int // 往 slice 里 写100 个数；
  for i := 0; i < 100; i++ {
   data = append(data, i)
  }
  atomic.StorePointer(&shareBufPtr, unsafe.Pointer(&data)) // 写完后，将共享缓存的指针指向它；
 }

 readDataFn := func() {
  data := atomic.LoadPointer(&shareBufPtr)
  fmt.Println(data, *(*[]int)(data)) // 打印共享缓存里的值
 }

接口

type xxx interface{}p *Programmer
func writeFirstProgram2(p *Programmer) {
 fmt.Printf("%T %vn", p, p.WriteHelloWorld())
}

interface{}
type Programmer interface {
    WriteHelloWorld() interface{}
}
注意： 1：父接口，只能是实例，不能是指针，可以看成父接口本身代表的就是指针实例 2：子类以 指针/实例 实现的接口，传入时，就得以对应的指针实例传入接口 3: 一个接口，通常 只定义 一个 方法，尽量保证 接口精简：

行为

type xxx struct{}

2:行为的方法实现，决定了最终传入的实例是什么

type Programmer interface {
    WriteHelloWorld() string
}

func (p *NoTypeProgrammer) WriteHelloWorld()
// 将 子行为 传入接口
type NoTypeProgrammer struct {
}

// 标识，要看最终这里的实现 ！！！
func (p *NoTypeProgrammer) WriteHelloWorld() string {
    return "System.out.Println("Hello World!")"
}

// 传入接口的  方法， 这里传 指针or实例都可以的
func writeFirstProgram(p Programmer) {
    fmt.Printf("%T %vn", p, p.WriteHelloWorld())
}
方法前面传入对象，是为了通过对象.s 调用内部的成员变量or成员函数

调用：

    noTypeProg := new(NoTypeProgrammer)
    writeFirstProgram(noTypeProg)
    //writeFirstProgram(NoTypeProgrammer{}) // error

func (p oTypeProgrammer) WriteHelloWorld()
// 标识，要看最终这里的实现 ！！！
func (p NoTypeProgrammer) WriteHelloWorld() string {
    return "System.out.Println("Hello World!")"
}

调用：

    noTypeProg := new(NoTypeProgrammer)
    writeFirstProgram(noTypeProg)
    writeFirstProgram(NoTypeProgrammer{}) // right

空接口

1： 空接口，代表 object 类型。需要通过断言判断类型

func DoSomething(p interface{}) {
 switch v := p.(type) {
 case int:
  fmt.Println("Integer", v)
 case string:
  fmt.Println("String", v)
 default:
  fmt.Println("Unknow Type")
 }
}

// 使用
DoSomething("10")

2：空接口可以接受任何类型的值:

var yzj interface{} // 空接口的使用，空接口类型的变量可以保存任何类型的值,空格口类型的变量非常类似于弱类型语言中的变量，未被初始化的 interface 默认初始值为 nil。

错误处理

1：使用多返回值，错误码来判断程序的处理；类似于 C ，通过引用或者指针传出来错误码；【最佳的是返回码 + 引用】；

模块

  • 同一个目录下只能有一个包名；
  • 包名推荐与目录名保持一致；
  • 每一个包内，只能有一个同名函数；
  • 同一个 package 内的 函数， 变量可以随意调用，不用导入

CSP

1：Communication sequential process: 进程间通过管道进行通信。

2：channel 的两种通信方式：

  • buffer- channel: 发送者和接受者有更松的耦合关系；
  • 容量没满， 放消息的人可以一直往里面放； 若容量已满， 直到接受者收走一个消息，能继续放入消息了，才能继续往下执行；
  • 接收者也类似： 只要是非空，能一直拿消息，向下执行；如果没有消息，需要一直等待，然后再向下继续执行；
chan stringchan int
go func(){}
go agt.EventProcessGroutine()   // 直接go 后面接一个 实名函数 也可以

协程是异步的， 主线程只会因为 通道阻塞。

6f9e9c1743e99a65121cf3124b2eb4d9.png
b22a0abac629c43d1ed9cfb5f90a85bc.png 
sequenceDiagram
    main ->> main:

    main ->> + AsyncService : 异步执行
    main ->> +otherTask: 和 AsyncService 同步执行
    otherTask-->>- main: return
    main ->> main: 等待 <-channel
    AsyncService ->> AsyncService: sleep
    AsyncService ->> AsyncService: sleep
    AsyncService ->>main: retCh <- ret， 通道在左边，是给通道赋值
    main ->> main: 唤起执行
    AsyncService ->>AsyncService: 继续执行
	main ->> main: End
	AsyncService ->>AsyncService: 继续执行
	AsyncService -->>- main: return
var wg sync.WaitGroup()
close(chan)
960fee057a0253a287dadb7ec4e1aa44.png

5： // 通道没关闭，其它协程会陷入死循环；

close(chan)struct{}{}

6： 可用于任意任务完成的场景。

一个 buffer 会阻塞其它协程的 写， N 个协程创建 N 个 Buffer， 就是非阻塞的了。

ch := make(chan string)

sync.WaitGroup()
a40ceb1dbf5497013bef71457ce455f7.png

8： 利用 channel 自身取的阻塞，有多少个协程，就循环多少次：

b6d6cde0b55111a8cb13fc86745d4950.png

Select

83046822822ab5c0bcc7319b82890d4d.png

Context

1： 可通过父协程取消所有子协程（非 Channel 实现）。

Sync.Once.Do()

sync.OnceDo（）

对象池

interface{}
4153ce3817714e321b1ff63b3972266e.png

sync.Pool

1: 生命周期不可控，随时会被 GC

b20519933f1c0b4f9ebd42e2a9c61cdf.png

bench

1:

48d043adeed51c4ba575d2cb4ea31752.png

2： bench 只能做参考，在不同的方式下，运行的次数不同。

3： bench 的使用

func BenchSyncmap(b *testing.B) {
 // bench 需要传入一个函数
 b.Run("map with RWLock", func(b *testing.B) {
  hm := CreateRWLockMap()
  benchMap(b, hm)
 })
}

反射

1： 可反射成员方法，编写更灵活的代码;

2: 特别是在解析 json 的时候；

3： 名字可以不一样，但是类型一样即可。 【万能程序】

不安全的编程

1： 类型转换

8acdd474d2c397ab0291059af53689a5.png 
atomic.StorePointer()actomic.LoadPointer()

实际上读和写是分开的两个 Buffer：

b5c29817a6ffaa0db76a6dcda0557a07.png

pipe 和 Filter

1： 定义接口

1e0a625c4aa37fd069ffd059510b8ed2.png 
Filter
72870b2eae7362269682bda514ccb564.png

3： 串起来调用：

3023ffe095129cfd8595813dc529e825.png
05ef34856ed7a84b889a336f79acc157.png

一个更常用的测试用例：

需要测试的接口，可以将各种实例放进去：

a0b54e8bbda0ad99700802800a35e5b3.png

实现一个 接口的经典例子【golang 的类组织方式，采用的是更扁平化的方式】：

737d65a9ce2638cb0f68694274e46088.png

创建对应的接口，并最终调用它：

487596c6aee456248e87521b25cf5a38.png

microKernel

1： 微服务模式， 总类管理子类的过程；

ba0342534d66a58bc4c39b73166c355f.png

JSON

1：通过 struct tag 来解析，相对比较简单，有点类似那个万能程序；

2：easyjson 需要手动生成 marsh 和 unmarsh 文件；

HTTP 服务

1： ROA：面向资源的架构

d91eed7fb88fc154d1de8f348e5cfcb9.png

性能分析

1： 常见性能调优过程：

13a0600d95ba309a08cb25196e3aaef4.png

2： 性能分析的常见指标：

  • 1：Wall Time;
  • 2: CPU Time;
  • 3: Block Time;
  • 4: Memory Allocation;
  • 5: GC Times/Time Spent

3： prof 常用指令：

  • 1： 查看CPU：
 go test -bench=.
 go test -bench=. -cpuprofile=cpu.prof
 go tool pprof cpu.prof top -cum list function
  • 2: 查看 Mem:
go test -bench=.
go test -bench=. -memprofile=mem.prof
go tool pprof mem.prof
top
list function

也可调用 对应的API，对某个函数 精准的输出 prof 文件

http://localhost:8081/debug/pprof/

5： 影响性能的几个要点：

文本处理和字符串连接

  • json 解析；
  • 字符串连接 用 bytes.Buffer 或 strings.Builder

协程锁：

  • 少用读锁；
  • 多用 concurrent-map, 实现协程安全的 数据共享；

GC 友好代码【尽量复用内存，减少内存分配】：

  • 大数组和结构体，在函数中传递时，使用指针；
  • 切片 最好初始化到合适的大小； 或者 用数组；

面向错误的设计

1： 隔离错误：

  • 从设计上隔离： Micro-kernal 设计；
  • 物理隔离，部署；

2： 重用和冗余的适当取舍；

3： 限流；

4： 快速拒绝比慢响应更优；（从web 的角度）

5： 不要无休止的等待；

6： 断路器： 利用好缓存，适当容错；

面向恢复的设计

1： 注意僵尸进程： 池化资源耗尽 和 死锁；

2： Let it crash 大多数 比 recover 程序更优（尽早发现错误尽早解决）；

3： 构建可恢复的系统：

  • 拒绝单实例；
  • 减少服务之间依赖；
  • 快速启动；
  • 尽量 无状态；

4：与客户端协商访问频次， 类似限流；