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:与客户端协商访问频次, 类似限流;