【Go语言】

type关键字的用法

• 定义结构体
• 定义接口
• 定义类型别名
• 类型定义
• 类型判断

别名实际上是为了更好地理解代码/

这里要分点进行记录  使用传值的例子，当两个类型不一样需要进行类型转换

type Myint int  // 自定义类型，基于已有的类型自定义一个类型

type Myint = int
// 在编译的时候，类型别名会被直接替换为int

上面两种方式定义的int是不同的，因为使用等于号是类型别名，不使用等于号的是重新定义了一个类型。

type Myint int 

如果我们即想使用int类型，又想让这种类型的变量有自己的方法，我们可以使用type自定义一种类型，这其实也算是一种结构体，我们可以为这个结构体创建一个方法，我们就可以进行调用这个方法。

type Myint=int

这个语句就是单独地给int变量起一个别名，其他用法和int一模一样。

结构体的定义和初始化

在go语言中没有面向对象的概念，但是可以使用面向对象的思想

type Person struct {
    name string
    age int
    address string
    height float32
}

// 在进行初始化的时候，我们有两种方式：
p1 := Peason{"xiaomin", 14, "佳", 1.8}

p2 := Person{
    name:"xiaomin",
    age:14,
}

匿名结构体  匿名函数

只能使用一次。

address := struct {
    province string
    city string
    address string
}{
    "北京市",
    "通州区",
    "xxx",
}

结构体嵌套

有两种嵌套方式

type Person struct {
    name string
    age int
}

type student struct {
    p Person
    score int
}

type student struct {
    Person
    score int
}

匿名定义中有一些问题，如果匿名结构体中有name，但是在外边的结构体中也有name，那么我们会发现外部的结构体的name的优先级大于匿名结构体中的优先级。

结构体定义方法

接收器有两种形态，一种是值传递，一种是指针传递，当我们需要进行修改结构体中的数值或者传递的结构体的容量很大时，我们需要进行指针传递。

如果接收器是指针类型，但是我们是值类型，我们可以进行调用函数的，同理，另一种情况也是可以的。

指针：

go语言中限制了指针的运算，在C语言中，我们可以使用指针进行加减运算， 

指针的初始化

指针是需要进行初始化的

在初始化的时候，有两个关键字：make ，new  

map channel  slice  初始化推荐使用make方法

指针初始化推荐使用new函数，指针需要进行初始化，否则会出现nil pointer

map必须初始化，否则会出现panic 

nil在go中的细节

不同类型的数据的零值不一样，

bool false

numbers 0

string ""

pointer nil

slice nil

map nil

channel  interface function nil

struct 的默认值不是nil，默认值是具体字段的默认值

slice的底层介绍？？？？？？？等会看一看

map也分为两种 nil map 和 empty map 在大部分场景下，nil map 和 empty map一样，但是当我们给nil map 进行赋值的时候，会进行panic

接口

什么是鸭子类型？

方法。动词，具备某些方法，go语言中强调的是动作

鸭子类型强调的是外部行为，而不是内部的结构

如何定义一个接口

type Duck interface{
    // 方法的申请
    Gaga()
    Walk()
    Swiming()
}

type pskDuck struct {
    legs int
}

func (pd *pskDuck) Gaga() {
    fmt.Println("this is walking...")
}

func main() {
    var d Duck = &pskDuck{}
    d.Gaga()
}

多接口的实现  不是很懂

如果有两个接口中的函数出现重复，说明我们可以将函数进行复用，我们可以实现接口进行解耦。

type MyWriter interface{
    Write(string) error
}

type MyCloser interface{
    Close() error
}

type WriteClose struct {
    MyWriter  // interface 也是一种类型 
}

func (wc *WriteClose) Writer(s string) error {
    fmt.Println("this is writer)
    return nil
}

func (wc *WriteClose) Close() error {
    fmt.Println("this is closer")
    return nil
}

在go语言中，多接口的实现是通过组合接口来实现的，go不支持多重继承，但是可以让一个类型实现多个接口，具体来说，只要一个类型实现了某些方法，他就自动实现了相应的接口。通过这种方式，go语言允许一个类型轻松实现多个接口，促进了灵活的设计和代码复用。

通过interface解决动态类型传参

我们在实现一些

使用断言转换类型  

但是还是没有解决问题

使用switch语句，断言处理分支语句可以用到

a.(type) 可以判断是什么类型 

但是更通用的写法是泛型。

string.Split

接口嵌套

接口遇到了slice的常见错误

单元测试

Go的并发编程

go的并发编程初体验

       在php，java，python等语言中，都是有多线程编程，多进程编程，多线程和多进程存在的问题主要是耗费内存。在进行进程切换和线程切换的时候，CPU会消耗一些资源。因此在go语言中，我们推出了协程（用户级线程，绿程，轻量级线程）。

       在协程中，内存占用小（2k），切换快，在go语言的协程中，go余元诞生之后就只有协程可以使用——goroutine，非常方便。我们可以在程序中使用协程创建出10万以上的协程，但是线程在程序中只能创建出100多个。下面，我们来看一看协程的代码：

func asyncPrint() {
    fmt.Println("加油旭杏")
}

// 主协程
func main() {
    go asyncPrint()
}

       上述代码是单个协程的调用，如果我们想使用多协程进行调用，我们可以使用循环来创建出多个协程。在创建协程的时候，我们有两种方式可以进行创建：一种是直接调用函数，一种是匿名函数。代码如下：

func Print() {
    fmt.Println("加油旭杏")
}

// 匿名结构体
func main() {
    go func() {
        for {
            fmt.Println("加油旭杏")
        }
    }

    time.Sleep(10 * time.Second)
}

       这里为了使程序不退出，我们在主协程中添加了睡眠时间，但是这种方式是非常挫的，在下面我们将会学习另一种等待协程的方法。

有一个问题：在C++中，如果有多个线程去执行一个加法运算，再执行一个减法运算会出现错误的，我们需要使用锁来进行让加减操作变成原子操作。如果操作简单，我们也可以使用原子变量来进行操作。

我们来看一看下面的代码：

for i := 0; i < 100; i++ {
    go func() {
        fmt.Println(i)
    }()
}

       第一个原因是我们使用匿名函数，也就是闭包，只能使用一次，第二个原因是我们使用了for循环，在for循环中，每一个变量会被重新使用，所以我们在调用加操作之前的变量和调用加操作之后的变量不是同一个变量，因为这个不是原子操作，也会CPU的调度有关。

go的gmp调度原理

这个gmp调度是分层的，我们先来看一看两层结构：一个是协程，一个是线程；在Go语言中，我们会将协程放入到线程去执行，

一张图   g  gorounte  m     p

我们在协程调度的时候，我们需要将

通过waitgroup来等待协程

       子gorounte如何通知到主的gorount自己结束了，主的gorounte如何知道子的gorounte已经结束了？？

       之前我们使用的例子是通过设置时间长度，但是我们不知道具体需要多少时间，所以这个代码是比较挫的，现在我们来认识一下WaitGroup。我们可以通过WaitGroup来将协程加入，如果我们事先知道协程的总数，可以直接在循环之前进行添加；如果我们不知道协程的总数，我们可以在循环的时候进行添加，每循环一次就添加一次，在添加之后我们需要将其进行done，类似于锁的机制一样，否则会造成死锁。因此，我们需要知道WaitGroup的add和done是需要配套使用的。最后我们需要进行wait方式进行等待。代码如下：

var wg sync.WaitGroup

// 我们需要监控多少个gotountine执行结束
wg.Add(100)
for i := 0; i < 100; i++ {
    go func(i int) {
        fmt.Println(i)
        wg.Done(); // Done和Add要成对出现
    }()
}

// 等待
wg.Wait()

       waitgroup主要用于gorountine的执行等待，add方法主要和done方法配套，最后要使用Wait方法进行等待，否则会出现死锁。

通过mutex和atomic完成全局变量的原子操作

       当我们需要进行共享资源的访问时，我们需要进行锁来对于资源竞争的保证。下面，我们来看一看代码：

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        lock.Lock()
        total += 1  // 这里会有竞争
        lock.Unlock()
    }
}

func sub() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        lock.Lock()
        total -= 1  // 这里会有竞争
        lock.Unlock()
    }
}

       当我们单独执行add函数或者单独执行sub函数，结果都是正确，但是当我们两个一起执行时，结果是错的，在Linux中，我们也出现了这种情况，因为a += 1不是原子操作，当CPU进行执行这段代码时，有可能中途退出，我们需要将这段代码进行保护起来，不要让他单独执行。在go语言中的锁是一个结构体，锁可以进行复制，但是复制过后锁就失去了自身的效果。下面是将加减操作改为原子操作，代码如下：

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&total, 1)
    }
}

func sub() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&total, -1)
    }
}

RWMutex 读写锁

       锁本质上就将并行的代码串行化，使用lock会影响性能。即使是设计锁，那么也应该保持并行。

       我们有两组协程，其中一组负责写数据，另一组负责读数据，web系统中绝大部分场景都是读多写少。虽然有多个gorounte，但是仔细分析我们会发现读是可以进行并发，读和写应该进行串行。我们在读的时候不能写，在写的时候不能读。

       这里我们就出现了读写锁m我们在进行读写锁的时候，我们需要将写操作的时候添加写锁:

• 写锁会防止别的写锁获取和读锁获取，使用WaitGroup
• 读锁不会阻止别人的锁，写锁会阻止别人的锁。

for i := 0; i < 5; ++i {
    go func() {
        defer wg.Done()
        for {
            rwlock.RLock()  // 加读锁，读锁不会阻止别人的读
            // TODO
            rwlock.RUnlock()
        }
    }
}

使用channel进行gorounte之间的通信

channel通道

在Go语言中不要通过共享内存进行通信，而是要通过通信来实现内存共享

       在C++中如何实现进程之间的通信，就是使用一个全局变量（两个线程都可以看到的）来实现通信，在其他语言中的多线程编程的时候，两个gorountine之间通信最常用的方式是channel，再加上语法糖让channel更加简单。

        channel初始化值为0，放值进去会阻塞。

func main() {
    var msg chan string // 定义一个通道
    msg = make(chan string, 1)
    
    msg <- "加油"
    data := <- msg
    fmt.Println(data)
}

       静态语言中使用channel，我们需要指明通道中的类型是什么？？注意箭头的指向，如果定义的通道在箭头的左边，则是将数据放入到通道中，如果定义的通道在箭头的右边，表示从通道中取数据。

channel有缓冲和无缓冲

var msg chan string

msg = make(chan string, 0)  // channel的初始值如果为0的话，你放值进去会进行阻塞

go func(msg chan string) {
    // go语言中有一种 happen-before机制，可以保证线程在channel中有值才会进行
    data := <- msg
    fmt.Println(data)
}(msg)

msg <- "加油旭杏" // 放值到channel中
time.Sleep(time.Second * 10)

无缓冲区channel适用于 通知，B要第一时间知道A是否完成

有缓冲区channel适用于消费者和生产者之间的通信 

go中channel的应用场景

• 消息传递，消息过滤
• 信号广播
• 事件订阅和广播
• 任务分发
• 结果汇总
• 并发控制
• 同步和异步

       在默认情况下，channel是双向的，但是我们经常使用channel作为参数进行传递，希望对方是单向使用的。 双向channel可以赋值给单向channel，但是单向channel不能赋值给双向channel，代码如下：

var ch1 chan int
var ch2 chan<- float64 // 单向channel，只能写入数据
var ch3 <-chan int // 只能读取数据

我们需要进行通信，就需要进行

通过channel实现交叉打印

我们需要使用channel进行打印，我们使用channel去进行通知，好像信号量，就是我们先打印数字然后唤醒打印字符的，在去打印字符，打印完字符再去唤醒打印数字的，如此交替执行。

监控gorounte的执行

       在go语言中，select类似于switch case 语句，但是select的功能和我们操作Linux里面提供的io的select，poll，epoll不一样，select主要作用于多个channel。

       现在有一个需求，我们现在有两个gorounte正在执行，但是我的主的gorounte中，当某一个执行完成之后，这个时候我们会立马知道