一，golang语言的数组与切片的区别

答：数组是一个固定长度的基本数据结构类型，slice是基于数组实现的一种长度可变的数据结构常用类型

具体区别如下：

1，创建方式不同，数组如abc := [...]int{1, 2, 3, 4}，slice如abc：=[]int{1, 2, 3,4} 或者 abc:=make([]int, 4, 10)

2，传递方式不同，数组是值传递，slice是引用传递

3，底层结构不同，数组基本数据类型，slice header的底层结构如下

type SliceHeader struct {

    Data uintptr

    Len  int

    Cap  int

}

其中SliceHeader是slice的运行时表示形式

参考：https://golang.org/ref/spec#Array_types

https://blog.golang.org/slices-intro

https://golang.org/pkg/reflect/#SliceHeader

二，golang的map类型与C++的map类型区别

1, golang的map类型，仅仅是一个哈希表，具体结构如下：

// A header for a Go map.

type hmap struct {

// Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.

// Make sure this stays in sync with the compiler's definition.

count    int // # live cells == size of map.  Must be first (used by len() builtin)

flags    uint8

B        uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)

noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details

hash0    uint32 // hash seed

buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.

oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing

nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

extra *mapextra // optional fields

}

参考：https://golang.org/src/runtime/map.go

其中特性如下：

申请必须make，或者使用:=方式，直接使用未初始化的map会panic；

引用类型；

key的类型必须是可比较类型；

并发使用不安全，需要加sync.RWMutex锁；

不指定迭代顺序，若需要顺序，则需要另外申请slice保存keys，然后sort.Ints(keys)；

参考：https://blog.golang.org/maps

2，C++的map的底层结构是红黑树

三，close通道关闭之后，Println输出之后的值，是否可以写入

1，close通道关闭之后，执行fmt.Println(<- ch)，若ch还有值，则输出ch的值，否则输出ch类型的默认值

2，若写入close的通道，则会panic，报错：panic: send on closed channel

四，简述chan类型

1，贯穿go语言的设计思想：不要通过共享内存来通信，而应该通过通信来共享内存。

2，类似一个先进先出队列；其中buf是一个循环链表结构；lock是互斥锁，所以线程安全；

3，分为无缓冲通道和有缓存通道，无缓冲通道必须先有消费协程，然后再可发送数据；

4，关闭chan，使用close，关闭之后不可再写入，但可以消费chan中的数据。

五，defer/panic/recover/return的理解

1，defer延迟执行

2.1 在函数return之前可以执行的一段代码，常用于资源释放，解锁，增加recover等操作。

2.2 多个defer执行顺序LIFO

例子：

package main

import (

"fmt"

"errors"

)

func main() {

  fmt.Printf("with named param, x: %d\n", namedParam())

  fmt.Printf("error from err1: %v\n", err1())

}

func namedParam() (x int) {

  x = 1

  defer func() { x = 2 }()

  return x

}

func err1() error {

  var err error

  defer func() {

      if r := recover(); r != nil {

        err = errors.New("recovered")

      }

  }()

  panic(`foo`)

  return err

}

输出：

with named param, x: 2

error from err1: <nil>

2，panic恐慌

2.1 内置函数，出现致命错误可以使用panic退出程序，如：panic("has error")

3，recover恢复

3.1 内置函数，重新获得panicking协程的控制，防止程序崩溃。注意像fatal的错误无法捕获，如map的并发读写：fatal error: concurrent map read and map write；死锁：fatal error: all goroutines are asleep - deadlock(申请无缓冲chan，直接生产数据会报此致命错误)

举例如下：

package main

import (

"fmt"

)

func main() {

defer fmt.Println("recover first ", recover())

defer func() {

if r := recover(); r != nil {

fmt.Println("recover ", r)

}

}()

defer fmt.Println("recover second ", recover())

panic("has error")

}

输出：

recover second <nil>

recover  has error

recover first  <nil>

4，return函数返回

4.1 return操作不是原子操作，过程具体可以分为三步：

首先赋值，把return的值赋给返回值

其次检查defer操作，有则调用，所以defer里面的函数是可以更改返回值的

最后返回返回值

六，简述内存逃逸，遇没有遇见过内存溢出及内存泄漏

1，内存逃逸

1.1 golang的内存分配逃逸于栈和堆

1.2 查看逃逸分析日志命令：go build -gcflags=-m

1.3 逃逸场景：指针逃逸，返回局部变量指针；大对象逃逸，申请局部变量是大对象的时候；动态类型，申请不确定大小内存的局部变量逃逸；闭包引用对象逃逸；

1.4 分析内存逃逸好处：可减少gc的压力，不逃逸则函数结束可以回收清理，不需要gc标识清理过程（所以指针传递不一定比值传递效率高）；栈上分配内存效率更高（不是绝对，栈也会扩容缩容）；静态分析，编译时完成（不影响性能）；

1.5 举个例子如下：

package main

import "fmt"

func fibo() func() int {

a, b := 0, 1

fmt.Println("first a, b", a, b)

return func() int {

a, b = b, a+b

return a

}

}

func main() {

f := fibo()

for i := 0; i < 6; i++ {

fmt.Printf("fib: %d\n", f())

}

f1 := fibo()

fmt.Printf("fib1: %d\n", f1())

fmt.Println("f:%p", &f, ", f1:%p", &f1)

}

运行输出：

first a, b 0 1

fib: 1

fib: 1

fib: 2

fib: 3

fib: 5

fib: 8

first a, b 0 1

fib1: 1

f:%p 0xc00000e028 , f1:%p 0xc00000e038

另外可以分析逃逸情况，输入命令：go build -gcflags=-m

输出如下：

# test/t_memory_escape

./main.go:9:13: inlining call to fmt.Println

./main.go:11:9: can inline fibo.func1

./main.go:27:13: inlining call to fmt.Printf

./main.go:33:12: inlining call to fmt.Printf

./main.go:35:13: inlining call to fmt.Println

./main.go:7:2: moved to heap: a

./main.go:7:5: moved to heap: b

./main.go:9:14: "first a, b" escapes to heap

./main.go:9:14: a escapes to heap

./main.go:9:14: b escapes to heap

可以看见a/b俩变量都逃逸了

2，内存溢出

2.1 golang的内存溢出基本没有见过，因为他的堆栈信息是可以扩容的，初始栈的容量是2k。

3，内存泄漏

3.1 golang的内存管理是使用gc机制自动化管理，使用方法是标记清理法，具体到三色标记法，另外使用屏障等技术提高回收效率。

3.2 golang是存在内存泄漏的，如文件/套接字等句柄没有关闭释放。这个没有释放的句柄会堆积在内存，gc并不会回收他们，导致内存泄漏。也有可能是启动的goroutine没有按预期退出，导致协程泄漏。

七，有没有使用过pprof/Benchmark工具

1，pprof工具

1.1 pprof工具是golang自带的性能分析神器

1.2 查看堆栈信息：go tool pprof http://localhost:6060/debug/pprof/heap

1.3 查看cpu信息：go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

1.4 查看goroutine信息：go tool pprof http://localhost:6060/debug/pprof/goroutine

1.5 查看trace路径信息：go tool pprof http://localhost:6060/debug/pprof/trace

2，Benchmark工具

1.1 性能测试工具

1.2 基准测试，需要_test.go结尾

八，简述golang语言的GMP机制

1，G是goroutine的缩写，用来表示协程；M是machine的缩写，用来表示线程，可以设置最大数量：SetMaxThreads；P是processor的缩写，用来表示逻辑处理器，p的个数配置GOMAXPROCS；

2，p队列有两种，一种全局队列，平衡多个p队列之间的任务，有锁；一种本地队列，无数据竞争，速度快，无锁；

3，启动方式，首先确定p的个数，若有设置环境变量$GOMAXPROCS或者是runtime.GOMAXPROCS()则按设置数量，否则使用默认值cpu核心数。其次动态调整m的数量，若没有足够的数量的m关联p中可运行的g的时候会新创m，如所有的m被阻塞时。

4，调度设计策略，首先当m无g可运行时，会优先从其他p本地队列盗取g来运行，本地队列没有，才会盗取全局队列；其次当本地m运行的g，因进行系统调用而阻塞时，m会释放绑定的p，p会转移到其他空闲的m上运行其他的g；最后go1.14及之后，属于基于信号的抢占式调度，一个g不能无限占用cpu时间，占用一定时间是可以被抢占的，防止其他g饿死；

参考：https://learnku.com/articles/41728

九，简述golang语言的gc机制

1，golang的gc（garbage collection）机制，使用方法是标记清理法，具体到三色标记法，另外使用屏障等技术提高回收效率。

十，简述golang语言cgo原理

1，cgo主要是用来创建go语言包调用c代码，详细可见：https://golang.org/pkg/cmd/cgo/