Go

1.Sync.map的底层实现

Sync.map有别于普通map的区别就是它可以实现map的线程安全，即多个goroutine同时对map进行操作时，不会造成不可预测的后果。

Sync.map共有四个字段，第一个为mutex，第二个为read，第三个为dirty，第四个为misses。

mutex即为互斥锁；read字段用来存放当前map的内容，当要读取map的内容时，都是先读取read字段里面的值，在读取dirty里面的内容；dirty字段用于往map里面写数据用，写的数据会暂时存放在dirty中；读read不需要加锁，而读或写dirty都需要加锁；misses用来统计有多少次需要去读dirty里面的数据，当超过一定次数后，会把dirty里面的数据合并到read中。

type Map struct {
    // 加锁作用，保护 dirty 字段
    mu Mutex
    // 只读的数据，实际数据类型为 readOnly
    read atomic.Value
    // 最新写入的数据
    dirty map[interface{}]*entry
    // 计数器，每次需要读 dirty 则 +1
    misses int
}

2.结构体的tag如何获取？

通过反射reflect.typeof().field().Tag.Get()获取，可参考下面的代码

func main() {
        type S struct {
                F string `species:"gopher" color:"blue"`  
        }
        s := S{}
        st := reflect.TypeOf(s)
        field := st.Field(0)
        fmt.Println(field.Tag.Get("color"), field.Tag.Get("species")) // blue gopher
}

3.Go实现单例模式（使用sync.Once）

首先说明什么是单例模式，单例模式即一个类只能有一个实例，且可以通过一个全局访问点去访问。单例模式常用于配置管理（应用程序可能需要一个只初始化一次的配置管理器）以及日志记录（日志记录器通常只需要一个实例，以避免日志信息的混乱）。

使用sync.Once.Do(func())实现单例模式的代码如下

package singleton
import (
    "sync"
)
type singleton struct {}
var instance *singleton
var once sync.Once
func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

4.Go实现单例模式（不使用sync.Once）

可以通过互斥锁来实现单例模式，但是这样做不如用sync.Once，因为我们无论做什么操作，即使现在这个实例已经被创建了，我们调用该函数的时候首先还是要加锁，会造成不必要的资源浪费，因为加锁和解锁都是有开销的。

var mu Sync.Mutex
func GetInstance() *singleton {
    mu.Lock()                    // 如果实例存在没有必要加锁
    defer mu.Unlock()
    if instance == nil {
        instance = &singleton{}
    }
    return instance
}

5.make和new的区别

make用于slice、map、channel的声明及初始化，new可以对任何数据类型进行声明；使用make不光分配内存空间，还会初始化内存空间；而使用new只会分配内存空间，如果不初始化，那么他就指向nil；make返回的是数据类型本身，而new返回的是指向该数据类型的指针。

6.Go项目引用包为什么用_以及包的init()函数

在go程序开始执行时，做的第一件事就是执行各个引入包的init()函数，init()函数无法被主动调用，只能是go运行时系统自动执行。如果我们只需要引入包而不需要包里面的其他函数以及变量，我们就需要在引入时用_注释，这样go编译器就不会提示我们包引入却未被调用。

7.如何判断一个结构体是否实现了某接口？

通过反射reflect.typeof().Implements()来实现，可看下面的代码具体实现

type SayHello interface {
        Hello()
}
type Person struct {
        Name string
}
func (p *Person) Hello() {
        fmt.Printf("Hello, %s!
", p.Name)
}
func main() {
        p := &Person{}
        rv := reflect.TypeOf(p)
        //Implements里面的内容也可以替换为var iface SayHello，reflect.TypeOf(&iface).Elem()
        if rv.Implements(reflect.TypeOf((*SayHello)(nil)).Elem()) {  //这种方式避免了显式声明一个接口变量
                fmt.Println("实现了SayHello接口")
        }
}

8.空interface{}和interface的底层数据结构

空接口，即 interface{}，可以存储任何类型的值。这是因为它没有定义任何方法。为了实现这种灵活性，它的运行时表示 (eface) 需要存储两部分信息_type和data

非空接口（例如 io.Reader、fmt.Stringer）定义了一组方法，任何具体类型都必须实现这些方法才能满足该接口。tab *itab这个字段是一个指向 itab（接口表）struct 的指针。itab 对于处理接口值上的方法调用至关重要。它存储了：

1. 指向具体值的 _type。
2. 指向接口本身的 _type（接口类型描述符）。
3. 一个函数指针列表（方法表），用于指向该接口定义的方法，具体指向当前接口持有的具体类型对这些方法的实现

//空接口
type eface struct {
        _type *_type         //接口内部存储的具体数据的真实类型
        data  unsafe.Pointer //data是指向真实数据的指针
}
//非空接口
type iface struct {
        tab  *itab
        data unsafe.Pointer //data是指向真实数据的指针
}

9.不同结构体或者不同切片怎么进行比较

使用反射reflect.DeepEqual()