night Documentation

Technical Documentation: talkgo/night

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`) Copy Section

[Go 夜读](https://talkgo.org/)

Star History Copy Chapter

加入方法 Copy Chapter

微信群 Copy Section

微信搜索 night_reading_go ，添加好友，备注你的姓名、公司、工作岗位和职责，
来自：GitHub，我会拉你入群。

在群内大家会就一些话题进行深入交流和探讨，说不定你还能遇到你的“导师”，我相信你会在里面受益良多，希望这个收益可以让你也能积极参与讨论，让微信群因你的加入而更精彩。

知识星球 Copy Section

2023 年，我的回顾与启航：从心出发。

2024 年，「保持好奇心，向 AI 进发」。

每一年，我们会为大家创建专门的微信群，在这里不仅会有知识星球内容提醒，还会有 Go 夜读各位讲师，你可以直接跟他们沟通。

在知识星球中，我们会放出「Go 夜读」每一期分享内容的资料。

我们的知识星球合伙人、嘉宾、资深工程师们，还会不定期的分享他们的精彩内容，以及他们的精彩分析。

除此之外，我们还筹备了以下专栏（相比于 2023 年，我们做了精简，以求做好）：

• #连接你我 通过 1:1 深度连接你，帮你走出精彩的职场之路。
• #成长手记 讲述我在经营「Go 夜读」过程中的一些经历。
• #好书共读 从书中学，书中自有黄金屋，书中自有颜如玉。我不是一个阅读达人，但是我会通过 #21天读书打卡 方式，认真读完每一本书，也会认真写下我的读后感。
• #从听中学 对于一个每个月收听超过 50 小时的重度播客听众来说，有太多精彩的内容和洞察想要与人分享、交流。从听（播客、视频）中学习行业大咖的经验和总结。
• #以练代学 开源项目的实践，7 天系列，30 天系列，效率工具，效率提升等。
• #管理手记 在现代管理学之父德鲁克看来，我们每一个人都是管理者，也会分享一些管理洞见，希望可以相互交流。
• #私享会 #星友局 属于我们自己的聚会。

我们的使命、愿景、价值观

• 使命：让每个开发者都能成长
• 愿景：深度连接 10000 个开发者
• 价值观：真诚、互助、尊重

欢迎你直接联系我或者提 Issues。

订阅 Go 夜读微信公众号 Copy Section

Go 夜读微信公众号主要是 Go 语言相关的话题，例如 Go 新特性分析， Go 周边新闻，Go Proposal解读， Go 源码剖析，以及 Go 工程实践。

Go 夜读还包括读书会和算法学习板块，读书会偶尔会有读书笔记分享，也有共读共学的读书会活动。
算法学习主要是以题解讨论形式在小范围内进行，偶尔会分享一些题解以供学习交流。

YouTube, Twitter, Facebook, Telegram, Slack Copy Section

我们的精神 Copy Chapter

开源！开源！开源！

重要的事，一定要说三遍。

希望有兴趣的小伙伴们一起加入，让我们一起把 『Go 夜读』建立成一个对大家都有帮助的开源社区。

我们的目标 Copy Chapter

我们希望可以推进大家深入了解 Go ，快速成长为资深的 Gopher 。
我们希望每次来了的人和没来的人都能够有收获，成长。

让每个想要学习的人都能参与进来，（包括初中高级 Go 工程师），
只有层次相当的人才有可能有思维的碰撞和交流，这样最终的产出也尽可能的高质量。

主题内容 Copy Chapter

Go 夜读将定期进行与 Go 语言相关的话题分享，例如源码阅读、工程实践等等。

• 如果你是一个 Go 新手，推荐阅读：Go 学习之路
• 如果你对 Go 语言的历史比较感兴趣，强烈推荐阅读：Go: A Documentary

我们的选题范围 Copy Section

我们的选题范围包括但不限于：

• 入门级
• 实操级
• 架构设计级
• 学习方法、习惯培养等
• 效率效能提升
• 论文研讨

我们的基本流程和分享方式 Copy Section

1. 通过提交 Issue 的方式来收集大家想要研究的与 Go 相关的源码库或源码模块等话题；
2. 提交的话题提案必须得到得到 SIG 小组的批准，并成功招募到分享人，该分享才会进入准备阶段。同样欢迎自荐话题并主动进行分享；
3. 分享人准备分享材料，并在材料准备完毕后交付 SIG 小组审阅；
4. 当 SIG 小组完成对材料的审阅后，将进行正式排期（这期间包括划定受众范围、审阅任务分工、分发排期计划等）；
5. 正式在线上进行分享；
6. 将视频进行后期剪辑并上传至视频网站，再进行后续分发。

注：

报名讲师并完成分享后，我们将赠送「Go 夜读」知识星球赠票。

回看地址 Copy Section

• Go 夜读（YouTuBe）
• Go 夜读（Bilibili）
• Go 夜读（腾讯视频） 已不再更新

往期分享 Copy Section

如何发起分享提案？ Copy Chapter

你是否经常困扰于某些 Go 话题没有人分享或者很少人关注？自己很想深入研究，但是却是形单影只，经常半途而废呢？

机会来了！！！参考如何发起分享提案

如何参与贡献？ Copy Chapter

想要参与贡献？阅读 如何参与贡献 查看指南。

Stargazers over time Copy Chapter

talklgo/night Star History and Stats

Contributors Copy Chapter

Code Contributors Copy Section

This project exists thanks to all the people who contribute.

Financial Contributors Copy Section

Become a financial contributor and help us sustain our community. [Contribute]

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [Contribute]

This project is supported by:

Contributors Copy Chapter

我非常重视每一个对这个项目的贡献者，我会将贡献者列表更新到这里，目前只有提交 Pull Request 的小伙伴，但是贡献不仅仅如此，还可以包括提交 Issue 以及在社群中有所贡献的人。

贡献者自己可以提 PR ，方法如下：

• 安装 npm install --save-dev all-contributors-cli
• sh gen_contributors.sh

贡献类型有多种，比如："code", "ideas","review","talk","tutorial"，你可以在 .all-contributorsrc 中修改。

Thanks goes to these wonderful people (emoji key):

This project follows the all-contributors specification. Contributions of any kind welcome!

Overview (`examples/gin_examples/README.md`) Copy Section

Gin Example

Endpoints

How to Start Copy Chapter

• make test
• make pg-up
• make run
• make pg-down

Development Flow Copy Chapter

1. Modfiy interfaces
2. Modfiy services
3. Modfiy repositories
4. Modfiy handlers
5. Modfiy routes

Test Flow Copy Chapter

1. Modfiy mocks
2. Modfiy handler_test

Note

1. Handlers only interact with Services
2. Services interact with Repository (DB)

Overview (`practice/reading-go-43/README.md`) Copy Section

、（-.-）、

reflect.Value 类型有一个 UnsafeAddr 方法。这个方法会返回一个 uintptr 类型的结果值。

这种行为是————————————>不安全<————————————————————的！！！！！！

UnsafeAddr 方法返回的指针值所指向的内存地址很可能会在之后的某个时刻被存入其他的东西，从而使得你对内存中数据的直接更改导致整个程序的崩溃。

这是一个被拒绝的proposal https://github.com/golang/go/issues/19752

Overview (`themes/hugo-material-docs/README.md`) Copy Section

Material Docs

A material design theme for Hugo.

Quick start Copy Chapter

Install with git:

git clone https://github.com/digitalcraftsman/hugo-material-docs.git themes/hugo-material-docs

Next, take a look in the exampleSite folder at. This directory contains an example config file and the content for the demo. It serves as an example setup for your documentation.

Copy at least the config.toml in the root directory of your website. Overwrite the existing config file if necessary.

Hugo includes a development server, so you can view your changes as you go -
very handy. Spin it up with the following command:

hugo server

Now you can go to localhost:1313 and the Material
theme should be visible. For detailed installation instructions visit the demo.

Noteworthy changes of this theme are listed in the changelog.

Acknowledgements Copy Chapter

A big thank you to Martin Donath. He created the original Material theme for Hugo's companion MkDocs. This port wouldn't be possible without him.

Furthermore, thanks to Steve Francia for creating Hugo and the awesome community around the project.

License Copy Chapter

The theme is released under the MIT license. Read the license for more information.

Overview (`content/articles/goroutine_and_channel/README.md`) Copy Section

goroutine和通道

• goroutine和通道
  • goroutine和通道
    • CSP并发模型
    • goroutine的调度模型
    • Go协程和主线程
    • goroutine入门
      • 设置Golang运行的CPU数
    • 管道
      • 加锁
      • 引入管道
      • channel介绍
    • 协程和管道
    • 代码效率
  • golang管道细节总结
    • 细节1
    • 细节2
    • 细节3

goroutine和通道 Copy Chapter

CSP并发模型 Copy Section

用于描述两个独立的并发实体通过共享的通讯 channel(管道)进行通信的并发模型

Golang 就是借用CSP模型的一些概念为之实现并发进行理论支持

process是在go语言上的表现就是 goroutine 是实际并发执行的实体，每个实体之间是通过channel通讯来实现数据共享。

goroutine的调度模型 Copy Section

MPG模型

M: 操作系统的主线程

P: 协程执行所需要的上下文

G:协程

具体了解可以点击这里

Go协程和主线程 Copy Section

1、Go主线程（线程或者叫进程）：一个Go主线程，可以起多个协程，协程就是轻量级的线程

2、Go协程的特点

有独立的栈空间

共享程序堆空间

调度由用户控制

协程是轻量级的线程【编译器做优化】

问题：

什么是栈空间&堆空间？

栈空间？
编译器自动分配释放，存放函数的参数值，局部变量的值等，其操作方式类似于数据结构的栈。

堆空间？
一般是由程序员分配释放，若程序员不释放的话，程序结束时可能由OS回收，值得注意的是他与数据结构的堆是两回事，分配方式倒是类似于数据结构的链表

怎么理解这段话？

注意我们此处谈到的堆和栈是对操作系统中的，这个和数据结构中的堆和栈还是又一定区别的。

栈: 可以简单得理解成一次函数调用内部申请到的内存，它们会随着函数的返回把内存还给系统。

func F() {
    temp := make([]int, 0, 20)
    ...
}

类似于上面代码里面的temp变量，只是内函数内部申请的临时变量，并不会作为返回值返回，它就是被编译器申请到栈里面。

申请到 栈内存 好处：函数返回直接释放，不会引起垃圾回收，对性能没有影响。

再来看看堆得情况之一如下代码：

func F() []int{
    a := make([]int, 0, 20)
    return a
}

而上面这段代码，申请的代码一模一样，但是申请后作为返回值返回了，编译器会认为变量之后还会被使用，当函数返回之后并不会将其内存归还，那么它就会被申请到 堆 上面了。

申请到堆上面的内存才会引起垃圾回收，如果这个过程（特指垃圾回收不断被触发）过于高频就会导致 gc 压力过大，程序性能出问题。

参考文献：

Golang内存分配逃逸分析

Go的变量到底在堆还是栈中分配

后面我会单独出一章介绍Golang 堆空间&栈空间理解

goroutine入门 Copy Section

例子：

package main

import (
	"fmt"
	"strconv"
	"time"
)

func test() {
	for i := 1; i <= 10; i++ {
		fmt.Println("test () hello world" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

func main() {

	// test()
	go test() //开启一个协程
	for i := 1; i <= 10; i++ {
		fmt.Println("main () hello golang" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}

}

运行结果：

main () hello golang1
test () hello world1
test () hello world2
main () hello golang2
test () hello world3
main () hello golang3
main () hello golang4
test () hello world4
test () hello world5
main () hello golang5
main () hello golang6
test () hello world6
test () hello world7
main () hello golang7
main () hello golang8
test () hello world8
main () hello golang9
test () hello world9
main () hello golang10
test () hello world10

运行结果： 说明main这个主线程和test协程同时运行

可以画个逻辑图来说明这个情况：

逻辑图讲解：

1、主线程是一个物理线程、直接作用在CPU上、是重量级的，非常耗费CPU资源

2、协程是主线程开启的，是轻量级的线程，是逻辑态，对资源消耗相对小

3、Golang的协程机制是重要的特点，可以轻松开启上万个协程

其他编程语言的开发机制一般基于线程，开启过多的线程，资源耗费大

这里就凸显了golang在并发上的优势了

设置Golang运行的CPU数

注意:

1、Go1.8之前 要进行设置下 可以更高效的利用CPU

2、GO1.8之后 默认让程序运行在多个核上 可以不用设置

这里使用的是go version go1.13.1

package main

import (
	"fmt"
	"runtime"
)

func main() {
	cpuNum := runtime.NumCPU()
	fmt.Println("cpunum:", cpuNum)

	//可以自己设置使用多个CPU
	runtime.GOMAXPROCS(cpuNum - 1)
	fmt.Println("ok")
}

管道 Copy Section

看一个例子来解释为什么要用到管道这个技术？

package main

import (
	"fmt"
	"time"
)

var (
	myMap = make(map[int]int, 10)
)

func test(n int) {
	res := 1
	for i := 1; i <= n; i++ {
		res *= i

	}

	myMap[n] = res

}

func main() {

	for i := 1; i <= 200; i++ {
		go test(i)
	}

	time.Sleep(time.Second * 10)

	//遍历结果
	for i, v := range myMap {
		fmt.Printf("map[%d]=%d\n", i, v)
	}

}

运行结果：

map[76]=0
map[81]=0
map[104]=0
map[117]=0
map[118]=0
map[124]=0
map[139]=0
map[153]=0
map[162]=0
map[2]=2
map[16]=20922789888000
....

发现的问题：

多个协程 同时写 会出现资源竞争

解决思路：

加锁

全局变量加锁同步

没有对全局变量加锁，会出现资源竞争问题，代码会报错： concurrent map writes

加入互斥锁

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	myMap = make(map[int]int, 10)

	//声明全局互斥锁
	//lock 是一个全局互斥锁
	//sync 表示同步
	//Mutex 表示互斥
	lock sync.Mutex
)

func test(n int) {
	res := 1
	for i := 1; i <= n; i++ {
		res *= i

	}

	//加锁
	lock.Lock()
	myMap[n] = res

	//解锁
	lock.Unlock()

}

func main() {

	for i := 1; i <= 200; i++ {
		go test(i)
	}

	//休眠几秒合适？
	time.Sleep(time.Second * 10)

	//遍历结果
	lock.Lock()
	for i, v := range myMap {
		fmt.Printf("map[%d]=%d\n", i, v)
	}
	lock.Unlock()

}

遍历结果也要加入锁机制， 原因：

程序从设计上可以指定10秒执行了所有协程，但是主线程并不知道，因此底层可能仍然出现资源争夺

引入管道

前面使用全局变量加锁解决 但不完美：

主要有三个地方：

1）主线程在等待所有gorouting全部完成的时间很难确定，这里设置了10秒，仅仅是估算

2）如果主线程休眠时间长了，会加长等待时间
如果等待时间短了，可能还有goroutine处于工作状态，
这时会随着主线程的退出而销毁

3）通过全局变量加锁，也并不利用协程对全局变量的读写操作（不知道在哪里加锁、释放锁）

channel介绍

1.主要有下面几个特点：

1.Channel本质就是一个数据结构 -队列

2.数据是先进先出

3.线程安全，多goroutine访问时，不需要加锁，就是说channel本身就是线程安全

4.channel是有类型的，一个string的channel只能存放string类型数据

2.基本使用：

定义 /声明 channel
var 变量 chan  数据类型
var intChan  chan int

说明：
1）channel是引用类型
2）channel必须初始化才能写入数据、即make后才能使用

3.例子

package main

import (
	"fmt"
)

func main() {
	var intChan chan int
	intChan = make(chan int, 3)

	fmt.Printf("intChan的值=%v\n", intChan) //intChan的值=0xc00001a100

}

4.管道写入

例子1：

package main

import (
	"fmt"
)

func main() {
	var intChan chan int
	intChan = make(chan int, 3)

	fmt.Println()

	//管道写入
	intChan <- 10
	num := 211
	intChan <- num

	//管道长度和容量
	fmt.Printf("channel len=%v cap=%v", len(intChan), cap(intChan))

}

例子2：

package main

import (
    "fmt"
)

func main() {
    var intChan chan int
    intChan = make(chan int, 3)

    fmt.Println()

    //管道写入
    intChan <- 10
    num := 211
    intChan <- num

    //当写入数据不能超过容量,超过报错
    intChan <- 50
    intChan <- 98

    //管道长度和容量
    fmt.Printf("channel len=%v cap=%v", len(intChan), cap(intChan))

}

例子3：

package main

import (
    "fmt"
)

func main() {
    var intChan chan int
    intChan = make(chan int, 3)

    fmt.Println()

    //管道写入
    intChan <- 10
    num := 211
    intChan <- num

    //当写入数据不能超过容量
    intChan <- 50

    //管道长度和容量
    fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))

    //读数据
    var num2 int
    num2 = <-intChan
    fmt.Println("num2=", num2)
    fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))

    //在没有使用协程的情况下，管道数据已经全部取出,再取就会报错deadlock
    num3 := <-intChan
    num4 := <-intChan
    num5 := <-intChan

    fmt.Println("num3=", num3, "num4=", num4, "num5=", num5)

}

5.管道细节总结：

1.channel只能存放指定的数据类型

2.channel的数据放满后，就不能再放入了

3.如果从channel取出数据后，可以继续放入

4.在没有使用协程的情况下，如果channel数据取完了再取， 就会报deadlock

6.channel的关闭

使用内置函数close可以关闭channel，当channel关闭后 就不能再向channel写数据

但是可以从channel读取数据

package main

func main() {
	intChan := make(chan int, 3)

	intChan <- 100
	intChan <- 200
	close(intChan)
	intChan <- 300  //panic: send on closed channel
}

7.channel的遍历

支持for-range的方式来遍历：

1.在遍历时，如果channel没有关闭，则出现deadlock

2.在遍历时，如果channel已经关闭，会正常遍历数据，遍历完后会退出遍历

package main

import "fmt"

func main() {
	intChan := make(chan int, 100)

	for i := 0; i < 100; i++ {
		intChan <- i * 2

	}

	//遍历,不能使用普通的for循环,取出来的不是值
	// for i := 0; i < len(intChan); i++ {
	//  fmt.Println("i=", i)
	// }

	//使用for-range循环,取出来的是值
	close(intChan)
	for v := range intChan {
		fmt.Println("v=", v)
	}

}

协程和管道 Copy Section

看一个例子：

package main

import (
	"fmt"
)

//write data
func writeData(intChan chan int) {
	for i := 1; i <= 50; i++ {
		intChan <- i
		fmt.Printf("writeData写数据=%v\n", i)
		// time.Sleep(time.Second)
	}
	close(intChan)
}

//read data
func readData(intChan chan int, exitChan chan bool) {

	for {
		v, ok := <-intChan
		if !ok {
			break
		}
		// time.Sleep(time.Second)
		fmt.Printf("readData 读到数据=%v\n", v)
	}

	//任务完成
	exitChan <- true
	close(exitChan)
}

func main() {

	//创建两个管道
	intChan := make(chan int, 10)
	exitChan := make(chan bool, 1)

	go readData(intChan, exitChan)
	go writeData(intChan)

	// time.Sleep(time.Second * 10)

	for {
		_, ok := <-exitChan
		if !ok {
			break
		}
	}

}

再看一个例子：

package main

import (
    "fmt"
)

func putNum(intChan chan int) {
    for i := 1; i <= 80; i++ {
        intChan <- i
    }

    //关闭intChan
    close(intChan)

}

func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

    var flag bool
    for {
        num, ok := <-intChan
        //intChan取不到
        if !ok {
            break
        }
        flag = true
        //判断是不是素数
        for i := 2; i < num; i++ {
            //说明num不是素数
            if num%i == 0 {
                flag = false
                break

            }
        }
        if flag {
            //放入primeChan
            primeChan <- num
        }
    }

    fmt.Println("有一个primeNum 协程因为取不到数据退出")
    //还不能关闭primeChan
    //向exitChan写入true
    exitChan <- true
}

func main() {

    intChan := make(chan int, 1000)
    primeChan := make(chan int, 2000) //放入结果
    exitChan := make(chan bool, 4)    //退出管道

    //开启一个协程,向intChan写入1-8000
    go putNum(intChan)

    //开启4个协程,从intChan取出数据,并判断是否为素数
    //如果是,就放入到primeChan
    for i := 0; i < 4; i++ {
        go primeNum(intChan, primeChan, exitChan)
    }

    //主线程处理
    go func() {
        for i := 0; i < 4; i++ {
            <-exitChan
        }

        //关闭primeChan
        close(primeChan)

    }()

    //遍历primeChan
    for {
        res, ok := <-primeChan
        if !ok {
            break
        }

        //结果输出
        fmt.Printf("素数=%d\n", res)

    }

    fmt.Println("main主线程退出")

}

运行结果：

有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
素数=1
素数=2
素数=3
素数=5
素数=7
素数=11
素数=13
素数=17
素数=19
素数=23
素数=29
素数=31
素数=37
素数=41
素数=43
素数=47
素数=53
素数=59
素数=61
素数=67
素数=71
素数=73
素数=79
main主线程退出

这里有个问题，就是结果显示不对：

代码里面增加休眠时间

修改后：

package main

import (
	"fmt"
	"time"
)

func putNum(intChan chan int) {
	for i := 1; i <= 80; i++ {
		intChan <- i
	}

	//关闭intChan
	close(intChan)

}

func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

	var flag bool
	for {
		time.Sleep(time.Millisecond)
		num, ok := <-intChan
		//intChan取不到
		if !ok {
			break
		}
		flag = true
		//判断是不是素数
		for i := 2; i < num; i++ {
			//说明num不是素数
			if num%i == 0 {
				flag = false
				break

			}
		}
		if flag {
			//放入primeChan
			primeChan <- num
		}
	}

	fmt.Println("有一个primeNum 协程因为取不到数据退出")
	//还不能关闭primeChan
	//向exitChan写入true
	exitChan <- true
}

func main() {

	intChan := make(chan int, 1000)
	primeChan := make(chan int, 2000) //放入结果
	exitChan := make(chan bool, 4)    //退出管道

	//开启一个协程,向intChan写入1-8000
	go putNum(intChan)

	//开启4个协程,从intChan取出数据,并判断是否为素数
	//如果是,就放入到primeChan
	for i := 0; i < 4; i++ {
		go primeNum(intChan, primeChan, exitChan)
	}

	//主线程处理
	go func() {
		for i := 0; i < 4; i++ {
			<-exitChan
		}

		//关闭primeChan
		close(primeChan)

	}()

	//遍历primeChan
	for {
		res, ok := <-primeChan
		if !ok {
			break
		}

		//结果输出
		fmt.Printf("素数=%d\n", res)

	}

	fmt.Println("main主线程退出")

}

运行结果：

素数=1
素数=2
素数=3
素数=5
素数=7
素数=11
素数=13
素数=17
素数=19
素数=23
素数=29
素数=31
素数=37
素数=41
素数=43
素数=47
素数=53
素数=59
素数=61
素数=67
素数=71
素数=73
素数=79
有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
有一个primeNum 协程因为取不到数据退出
main主线程退出

代码效率 Copy Section

1.普通方法

package main

import (
	"fmt"
	"time"
)

func main() {

	start := time.Now().Unix()
	for num := 1; num <= 80000; num++ {

		flag := true
		//判断是不是素数
		for i := 2; i < num; i++ {
			//说明num不是素数
			if num%i == 0 {
				flag = false
				break

			}
		}
		if flag {

		}
	}
	end := time.Now().Unix()
	fmt.Println("普通方法耗时=", end-start) //普通方法耗时= 3

}

2.使用了协程+管道

package main

import (
	"fmt"
	"time"
)

func putNum(intChan chan int) {
	for i := 1; i <= 80000; i++ {
		intChan <- i
	}

	//关闭intChan
	close(intChan)

}

func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

	var flag bool
	for {
		// time.Sleep(time.Millisecond)
		num, ok := <-intChan
		//intChan取不到
		if !ok {
			break
		}
		flag = true
		//判断是不是素数
		for i := 2; i < num; i++ {
			//说明num不是素数
			if num%i == 0 {
				flag = false
				break

			}
		}
		if flag {
			//放入primeChan
			primeChan <- num
		}
	}

	fmt.Println("有一个primeNum 协程因为取不到数据退出")
	//还不能关闭primeChan
	//向exitChan写入true
	exitChan <- true
}

func main() {

	intChan := make(chan int, 1000)
	primeChan := make(chan int, 20000) //放入结果
	exitChan := make(chan bool, 4)     //退出管道

	start := time.Now().Unix()
	//开启一个协程,向intChan写入1-8000
	go putNum(intChan)

	//开启4个协程,从intChan取出数据,并判断是否为素数
	//如果是,就放入到primeChan
	for i := 0; i < 4; i++ {
		go primeNum(intChan, primeChan, exitChan)
	}

	//主线程处理
	go func() {
		for i := 0; i < 4; i++ {
			<-exitChan
		}

		end := time.Now().Unix()
		fmt.Println("使用协程耗时=", end-start) //使用协程耗时= 1

		//关闭primeChan
		close(primeChan)

	}()

	//遍历primeChan
	for {
		_, ok := <-primeChan
		// res, ok := <-primeChan
		if !ok {
			break
		}

		//结果输出
		// fmt.Printf("素数=%d\n", res)

	}

	fmt.Println("main主线程退出")

}

3.优化版

在运行某个程序时，如何指定是否存在资源竞争问题？

方法很简单，在编译程序时，增加一个参数 -race

golang管道细节总结 Copy Chapter

细节1 Copy Section

package main

import (
    "fmt"
)

func main() {
    //管道可以声明只读或者只写

    //1.在默认情况下,管道是双向
    //var chan1 chan int //可读可写

    //2 声明为只写
    var chan2 chan<- int
    chan2 = make(chan int, 3)
    chan2 <- 20
    // num := <-chan2 //error

    //3 声明为只读
    var chan3 <-chan int
    chan3 = make(chan int, 3)
    // chan3 <- 20//error
    num := <-chan3

    fmt.Println("chan2=", chan2)

}

细节2 Copy Section

package main

import (
    "fmt"
)

func main() {
    //使用select 可以解决从管道取数据的阻塞问题

    //1.定义一个管道 10个数据int
    intChan := make(chan int, 10)
    for i := 0; i < 10; i++ {
        intChan <- i
    }

    //2.定义一个管道 5个数据string
    StringChan := make(chan string, 5)
    for i := 0; i < 5; i++ {
        StringChan <- "hello" + fmt.Sprintf("%d", i)
    }

    //传统方法在遍历管道时候 如果不关闭会阻塞会导致deadlock
    //问题在实际开发中可能我们不好确定什么时候关闭管道
    //可以使用select 方法解决
    // label:
    for {
        select {
        //注意:这里如果intChan一直没有关闭不会一直阻塞而deadlock
        //会自动到下一个case匹配
        case v := <-intChan:
            fmt.Printf("从intChan读取数据%d\n", v)
        case v := <-StringChan:
            fmt.Printf("从StringChan读取数据%s\n", v)
        default:
            fmt.Printf("都取不到\n")
            // break label //跟label配合使用
            return
        }

    }

}

细节3 Copy Section

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    for i := 0; i < 10; i++ {
        time.Sleep(time.Second)
        fmt.Println("hello world")
    }
}

func test() {

    //使用defer+recover
    defer func() {
        //捕获抛出的panic
        if err := recover(); err != nil {
            fmt.Println("test()发生错误", err)
        }

    }()
    var myMap map[int]string
    myMap[0] = "golang"
}

func main() {
    go sayHello()
    go test()

    for i := 0; i < 10; i++ {
        fmt.Println("main() ok=", i)
    }

}

Overview (`content/articles/how_to_test/README.md`) Copy Section

title: "how to testing" date: 2018-12-25T00:00:00+08:00 author: [email protected] Copy Chapter

HOW TO TESTING

原文/源码参考：

• how_to_test

作者：[email protected]

测试的作用：

• 验证代码是否符合预期
• 资源竞争检查：race detect
• 调优：profiling：memory/cpu

原始代码 Copy Chapter

代码功能：访客记次数。

package main

import (
	"fmt"
	"log"
	"net/http"
)

var counter = map[string]int{}

func handleHello(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	counter[name]++

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Write([]byte("<h1 style='color: " + r.FormValue("color") +
		"'>Welcome!</h1> <p>Name: " + name + "</p> <p>Count: " + fmt.Sprint(counter[name]) + "</p>"))
}

func main() {
	http.HandleFunc("/hello", handleHello)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

运行：

go run main.go

浏览器访问：

本地日志记录：

测试规范 Copy Section

1. 运行测试：

   1. 测试：go test
   2. 压力测试：go test -bench
   3. 测试覆盖：go test -cover

2. 测试规范：

   1. 测试函数示例

      go Copy

      // go test or go test -v
      func TestXxx(*testing.T)
      
      // go test -bench
      func BenchmarkXxx(*testing.B)

      Xxx不能以小写字母开头。

   2. 测试文件规范：文件名以_test.go结尾。

   3. 在测试函数里面使用：Error，Fail或者相关的函数标示相关错误。

3. 例子：

   1. 单元测试：

      go Copy

      func TestTimeConsuming(t *testing.T) {
          if testing.Short() {
              t.Skip("skipping test in short mode.")
          }
          ...
      }

   2. 压力测试：

      go Copy

      func BenchmarkHello(b *testing.B) {
          for i := 0; i < b.N; i++ {
              fmt.Sprintf("hello")
          }
      }

   3. Examples：

      go Copy

      func ExampleHello() {
          fmt.Println("hello")
          // Output: hello
      }
      
      func ExampleSalutations() {
          fmt.Println("hello, and")
          fmt.Println("goodbye")
          // Output:
          // hello, and
          // goodbye
      }

测试用例 Copy Section

运行测试

使用go test运行测试。

➜  how_to_test git:(how_to_test) ✗ go test
?       _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      [no test files]

也可以使用Golang的TDD小工具：goconvey

安装：go get github.com/smartystreets/goconvey

介绍: GoConvey is awesome Go testing

运行：goconvey

效果截图：

测试用例

创建main_test.go，

touch main_test.go

编写第一个测试用例：

func TestHelloHandleFunc(t *testing.T) {
	rw := httptest.NewRecorder()
	name := "zouying"
	req := httptest.NewRequest(http.MethodPost, "/hello?name="+name, nil)
	handleHello(rw, req)

	if rw.Code != http.StatusOK {
		t.Errorf("status code not ok, status code is %v", rw.Code)
	}

	if len(counter) != 1 {
		t.Errorf("counter len not correct")
	}

	if counter[name] != 1 {
		t.Errorf("counter value is error: visitor=%s count=%v", name, counter[name])
	}
}

运行测试：go test -v：

➜ how_to_test git:(how_to_test) ✗ go test -v
=== RUN TestHelloHandleFunc
INFO[0000] visited count=1 module=main name=zouying
--- PASS: TestHelloHandleFunc (0.00s)
PASS
ok _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test 0.015s

运行测试覆盖：go test -cover

➜ how_to_test git:(how_to_test) ✗ go test -cover
INFO[0000] visited count=1 module=main name=zouying
PASS
coverage: 62.5% of statements
ok _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test 0.021s

查看覆盖的代码：

#!/bin/bash
go test -coverprofile=coverage.out
go tool cover -html=coverage.out

➜ how_to_test git:(how_to_test) ✗ go test -coverprofile=/tmp/coverage.out
INFO[0000] visited count=1 module=main name=zouying
PASS
coverage: 62.5% of statements
ok _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test 0.015s
➜ how_to_test git:(how_to_test) ✗ go tool cover -html=/tmp/coverage.out

效果图为：

绿色的表示测试代码覆盖住的，红色的表示没有覆盖。

第一个测试用例是直接测试http处理函数，我们使用了httptest.NewRecorder()创建ResponseRecorder对象，其中实现了 ResponseWriter interface。该对象在内存中记录了http response的状态。

还有一种测试方法是运行一个HTTP Server，使用HTTP Client请求该Server对应的接口。

httptest package中提供了NewServer方法，监听HandlerFunc处理函数，启动Server，启动Server的地址通过URL成员获得，例如：http://127.0.0.1:52412。需要注意的是，使用完毕后记得调用关闭：Close()。

代码如下，

func TestHTTPServer(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(handleHello))
	defer ts.Close()

	logrus.Infof("server url: %s", ts.URL)

	testURL := ts.URL + "/hello?name=zouying"
	resp, err := http.Get(testURL)
	if err != nil {
		t.Error(err)
		return
	}
	if g, w := resp.StatusCode, http.StatusOK; g != w {
		t.Errorf("status code = %q; want %q", g, w)
		return
	}
}

运行测试，

➜  how_to_test git:(master) ✗ go test -v -run=TestHTTPServer
=== RUN   TestHTTPServer
INFO[0000] server url: http://127.0.0.1:52506
INFO[0000] visited                                       count=1 module=main name=zouying
--- PASS: TestHTTPServer (0.00s)
PASS
ok      _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      0.015s

测试技巧：表格测试 (Table Based Tests)

代码如下，

func TestHelloHandlerMultiple(t *testing.T) {
	tests := []struct {
		name string
		wCnt int
	}{
		{name: "zouying", wCnt: 1},
		{name: "zouying", wCnt: 2},
		{name: "user2", wCnt: 1},
		{name: "user3", wCnt: 1},
	}

	for _, tc := range tests {
		rw := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodPost, "/hello?name="+tc.name, nil)
		handleHello(rw, req)

		if rw.Code != http.StatusOK {
			t.Errorf("status code not ok, status code is %v", rw.Code)
		}

		if counter[tc.name] != tc.wCnt {
			t.Errorf("counter value is error: visitor=%s count=%v", tc.name, counter[tc.name])
		}
	}
}

运行测试，

➜  how_to_test git:(how_to_test) ✗ go test -run=TestHelloHandlerMultiple
INFO[0000] visited                                       count=1 module=main name=zouying
INFO[0000] visited                                       count=2 module=main name=zouying
INFO[0000] visited                                       count=1 module=main name=user2
INFO[0000] visited                                       count=1 module=main name=user3
PASS
ok      _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      0.016s

测试工具：testify

使用工具介绍各种 if {}判断，产生大量的冗余代码。

代码，

func TestHelloHandlerMultipleWithAssert(t *testing.T) {

	tests := []struct {
		name string
		wCnt int
	}{
		{name: "zouying", wCnt: 1},
		{name: "zouying", wCnt: 2},
		{name: "user2", wCnt: 1},
		{name: "user3", wCnt: 1},
	}

	for _, tc := range tests {
		rw := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodPost, "/hello?name="+tc.name, nil)
		handleHello(rw, req)

		assert.Equal(t, http.StatusOK, rw.Code)
		assert.Equal(t, tc.wCnt, counter[tc.name])
	}
}

Sub Test

func TestHelloHandlerInSubtest(t *testing.T) {

	tests := []struct {
		name string
		wCnt int
	}{
		{name: "zouying", wCnt: 1},
		{name: "user2", wCnt: 1},
		{name: "user3", wCnt: 1},
	}

	for _, tc := range tests {
		t.Run("test-"+tc.name, func(t *testing.T) {
			rw := httptest.NewRecorder()
			req := httptest.NewRequest(http.MethodPost, "/hello?name="+tc.name, nil)
			handleHello(rw, req)

			assert.Equal(t, http.StatusOK, rw.Code)
			assert.Equal(t, tc.wCnt, counter[tc.name])
		})
	}
}

运行测试，

➜  how_to_test git:(how_to_test) ✗ go test -v . -run=TestHelloHandlerInSubtest
=== RUN   TestHelloHandlerInSubtest
=== RUN   TestHelloHandlerInSubtest/test-zouying
time="2018-12-23T23:07:19+08:00" level=info msg=visited count=1 module=main name=zouying
=== RUN   TestHelloHandlerInSubtest/test-user2
time="2018-12-23T23:07:19+08:00" level=info msg=visited count=1 module=main name=user2
=== RUN   TestHelloHandlerInSubtest/test-user3
time="2018-12-23T23:07:19+08:00" level=info msg=visited count=1 module=main name=user3
--- PASS: TestHelloHandlerInSubtest (0.00s)
    --- PASS: TestHelloHandlerInSubtest/test-zouying (0.00s)
    --- PASS: TestHelloHandlerInSubtest/test-user2 (0.00s)
    --- PASS: TestHelloHandlerInSubtest/test-user3 (0.00s)
PASS
ok      _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      0.016s

Data Race Detect Copy Section

多个goroutine同时访问共享数据时，如果数据不是线程安全的，那么有可能会产生data race。

HOW TO

go test -race

测试代码

func TestHelloHandlerDetectDataRace(t *testing.T) {

	tests := []struct {
		name string
		wCnt int
	}{
		{name: "zouying", wCnt: 1},
		{name: "zouying", wCnt: 2},
		{name: "user2", wCnt: 1},
		{name: "user3", wCnt: 1},
	}

	for _, tc := range tests {
		rw := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodPost, "/hello?name="+tc.name, nil)
		handleHello(rw, req)

		assert.Equal(t, http.StatusOK, rw.Code)
		assert.Equal(t, tc.wCnt, counter[tc.name])
	}
}

运行测试

➜  how_to_test git:(how_to_test) ✗ go test -race -v . -run=TestHelloHandlerDetectDataRace
=== RUN   TestHelloHandlerDetectDataRace
time="2018-12-23T22:58:22+08:00" level=info msg=visited count=1 module=main name=zouying
time="2018-12-23T22:58:22+08:00" level=info msg=visited count=2 module=main name=zouying
time="2018-12-23T22:58:22+08:00" level=info msg=visited count=1 module=main name=user2
time="2018-12-23T22:58:22+08:00" level=info msg=visited count=1 module=main name=user3
--- PASS: TestHelloHandlerDetectDataRace (0.00s)
PASS
ok      _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      1.029s

测试通过，是否证明了我们的代码是没有问题的呢？

其实并非如此，只是没有检测出来。为什么没有检测出来？

是因为没有多个goroutine同时运行，访问共同的数据。

修改代码

func TestHelloHandlerDetectDataRace(t *testing.T) {

	tests := []struct {
		name string
		wCnt int
	}{
		{name: "zouying", wCnt: 1},
		{name: "user2", wCnt: 1},
		{name: "user3", wCnt: 1},
	}

	var wg sync.WaitGroup
	wg.Add(len(tests))
	for _, tc := range tests {
		name := tc.name
		want := tc.wCnt

		go func() {
			defer wg.Done()

			rw := httptest.NewRecorder()
			req := httptest.NewRequest(http.MethodPost, "/hello?name="+name, nil)
			handleHello(rw, req)

			assert.Equal(t, http.StatusOK, rw.Code)
			assert.Equal(t, want, counter[name])
		}()
	}
	wg.Wait()
}

运行测试

/* Detailed source-code truncated for AI context efficiency. */

分析报错

==================
WARNING: DATA RACE
Write at 0x00c0000a8f90 by goroutine 8:
  runtime.mapassign_faststr()
      /usr/local/go/src/runtime/map_faststr.go:190 +0x0
  _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test.handleHello()
      /Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test/main.go:14 +0x11c
  _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test.TestHelloHandlerDetectDataRace.func1()
      /Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test/main_test.go:144 +0x211

Previous read at 0x00c0000a8f90 by goroutine 7:
  runtime.mapaccess1_faststr()
      /usr/local/go/src/runtime/map_faststr.go:12 +0x0
  _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test.handleHello()
      /Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test/main.go:14 +0xbc
  _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test.TestHelloHandlerDetectDataRace.func1()
      /Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test/main_test.go:144 +0x211

• goroutine 8, goroutine 7, ...
• DATA RACE
• how_to_test/main.go:14：counter[name]++
• runtime/map_faststr.go:190

原因是因为在多个goroutine中，对map同时进行了++操作，而在go中，map又不是线程安全的（线程安全的map参考sync包中的map），需要进行保护。

修复race

如果咱们的代码中有data race，那么一般使用下面方式可以避免，

• 使用channel。

  • Share Memory By Communicating

  • Go by Example: Channels

    • go Copy

      messages := make(chan string, 2)
      
      messages <- "buffered"
      messages <- "channel"

• 使用mutex。

  • Package sync
  • sync.Mutex - Tour of Go
  • Go by Example: Mutexes

• 使用atomic。

  • Go by Example: Atomic Counters

    go Copy

    import "sync/atomic"
    
    var ops uint64
    
    for i := 0; i < 50; i++ {
        go func() {
            for {
                atomic.AddUint64(&ops, 1)
            }
        }()
    }
    
    opsFinal := atomic.LoadUint64(&ops)

  • sync/atomic package

引入mutex解决问题

1. 增加var mu sync.Mutex对counter map进行保护。
2. 在对counter访问前进行Lock操作，访问结束后，进行Unlock操作。

修改代码为，

package main

import (
	"fmt"
	"net/http"
	"sync"

	"github.com/sirupsen/logrus"
)

var counter = map[string]int{}
var mu sync.Mutex // mutex for counter

func handleHello(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	mu.Lock()
	counter[name]++
	cnt := counter[name]
	mu.Unlock()

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Write([]byte("<h1 style='color: " + r.FormValue("color") +
		"'>Welcome!</h1> <p>Name: " + name + "</p> <p>Count: " + fmt.Sprint(cnt) + "</p>"))

	logrus.WithFields(logrus.Fields{
		"module": "main",
		"name":   name,
		"count":  cnt,
	}).Infof("visited")
}

func main() {
	logrus.SetFormatter(&logrus.JSONFormatter{})

	http.HandleFunc("/hello", handleHello)
	logrus.Fatal(http.ListenAndServe(":8080", nil))
}

测试代码，

➜  how_to_test git:(how_to_test) ✗ go test -v -race . -run=TestHelloHandlerDetectDataRace
=== RUN   TestHelloHandlerDetectDataRace
time="2018-12-24T10:11:23+08:00" level=info msg=visited count=1 module=main name=user3
time="2018-12-24T10:11:23+08:00" level=info msg=visited count=1 module=main name=zouying
time="2018-12-24T10:11:23+08:00" level=info msg=visited count=1 module=main name=user2
--- PASS: TestHelloHandlerDetectDataRace (0.00s)
PASS
ok      _/Users/zouying/src/Github.com/ZOUYING/learning_golang/how_to_test      1.025s

具体参考：

• https://golang.org/pkg/testing/

Overview (`content/articles/sony-gobreaker/README.md`) Copy Section

title: "Sony gobreaker熔断器源码分析" date: 2018-07-26T00:00:00+08:00 author: [email protected] Copy Chapter

最近看了一下go-kit，发现这个微服务框架的熔断器，也是使用sony开源的作为基础。
sony开源在 github 的熔断器
在源代头注释中发现，原来sony实现的是微软2015时公布的CircuitBreaker标准，果然微软才开源界的大神。

1）微软定义的 Circuit breaker Copy Chapter

微软的原文件在此：https://msdn.microsoft.com/en-us/library/dn589784.aspx
名不知道怎么正确翻译，直观翻译，可能叫：环形熔断器（或叫：循环状态自动切换中断器）。
因为它是在下面3个状态循环切换 ：

Closed 
         /    \
 Half-Open <--> Open

初始状态是：Closed，指熔断器放行所有请求。
达到一定数量的错误计数，进入Open 状态，指熔断发生，下游出现错误，不能再放行请求。
经过一段Interval时间后，自动进入Half-Open状态，然后开始尝试对成功请求计数。
进入Half-Open后，根据成功/失败计数情况，会自动进入Closed或Open。

2）sony开源的go实现 Copy Chapter

// 从定义的错误来看，sony的应该增加了对连接数进行了限制 。
 var (
	// ErrTooManyRequests is returned when the CB state is half open and the requests count is over the cb maxRequests
	ErrTooManyRequests = errors.New("too many requests")
	// ErrOpenState is returned when the CB state is open
	ErrOpenState = errors.New("circuit breaker is open")
)

2.1） 通过Settings的实现，了解可配置功能： Copy Section

type Settings struct {
	Name          string
	MaxRequests   uint32        // 半开状态期最大允许放行请求：即进入Half-Open状态时，一个时间周期内允许最大同时请求数（如果还达不到切回closed状态条件，则不能再放行请求）。
	Interval      time.Duration // closed状态时，重置计数的时间周期；如果配为0，切入Open后永不切回Closed--有点暴力。
	Timeout       time.Duration // 进入Open状态后，多长时间会自动切成 Half-open，默认60s，不能配为0。

    // ReadyToTrip回调函数：进入Open状态的条件，比如默认是连接5次出错，即进入Open状态，即可对熔断条件进行配置。在fail计数发生后，回调一次。
	ReadyToTrip   func(counts Counts) bool 

	// 状态切换时的熔断器
	OnStateChange func(name string, from State, to State)
}

2.2）核心的*执行函数*实现 Copy Section

要把熔断器使用到工程中，只需要，实例化一个gobreaker，再使用这个Execute包一下原来的请求函数。

func (cb *CircuitBreaker) Execute(req func() (interface{}, error)) (interface{}, error) {
	generation, err := cb.beforeRequest() // 
	if err != nil {
		return nil, err
	}

	defer func() {
		e := recover()
		if e != nil {
			cb.afterRequest(generation, false)
			panic(e) // 如果代码发生了panic，继续panic给上层调用者去recover。
		}
	}()

	result, err := req()
	cb.afterRequest(generation, err == nil)
	return result, err
}

2.2 关键 func beforeRequest() Copy Section

函数做了几件事：

0. 函数的核心功能：判断是否放行请求，计数或达到切换新条件刚切换。
1. 判断是否Closed，如是，放行所有请求。
   • 并且判断时间是否达到Interval周期，从而清空计数，进入新周期，调用toNewGeneration()
2. 如果是Open状态，返回ErrOpenState，---不放行所有请求。
   • 同样判断周期时间，到达则 同样调用 toNewGeneration(){清空计数}
3. 如果是half-open状态，则判断是否已放行MaxRequests个请求，如未达到刚放行；否则返回:ErrTooManyRequests。
4. 此函数一旦放行请求，就会对请求计数加1（conut.onRequest())，请求后到另一个关键函数 : afterRequest()。

2.3 关键 func afterRequest() Copy Section

1. 函数核心内容很简单，就对成功/失败进行计数，达到条件则切换状态。
2. 与beforeRequest一样，会调用公共函数 currentState(now)
   • currentState(now) 先判断是否进入一个先的计数时间周期(Interval), 是则重置计数，改变熔断器状态，并返回新一代。
   • 如果request耗时大于Interval, 几本每次都会进入新的计数周期，熔断器就没什么意义了。

代码的核心内容 Copy Chapter

1. 使用了一个generation的概念，每一个时间周期(Interval)的计数(count)状态称为一个generation。
2. 在before/after的两个函数中，实现了两个状态自动切换的机制：
   • 在同一个generation(即时间）周期内，计数满足状态切换条件，即自动切换；
   • 超过一个generation时间周期的也会自动切换；
3. 没有使用定时器，只在请求调用时，去检测当时状态与时间间隔。

Overview (`content/articles/sync/README.md`) Copy Section

title: 说明 Copy Chapter

内容均来自OSC_梦朝思夕博客,51CTO_梦朝思夕博客

Index (`content/_index.md`) Copy Section

title: "Go 夜读" date: 2018-11-15T12:32:37+08:00 weight: 1 Copy Chapter

Articles Index (`content/articles/_index.md`) Copy Section

title: "分享文章" date: 2018-11-15T12:32:37+08:00 weight: 5 Copy Chapter

Discuss Index (`content/discuss/_index.md`) Copy Section

title: "夜读讨论" date: 2018-11-15T12:32:37+08:00 weight: 5 Copy Chapter

Harvest Index (`content/harvest/_index.md`) Copy Section

title: "你的收获" date: 2019-01-10T11:00:00+08:00 weight: 8 Copy Chapter

Interview Index (`content/interview/_index.md`) Copy Section

title: "面试专题" date: 2018-11-15T12:32:37+08:00 weight: 7 Copy Chapter

Night Index (`content/night/_index.md`) Copy Section

title: "Go 源码阅读" date: 2018-11-15T12:32:37+08:00 weight: 2 Copy Chapter

Other Index (`content/other/_index.md`) Copy Section

title: "其他" date: 2018-11-15T12:32:37+08:00 weight: 10 Copy Chapter

Proposal Index (`content/proposal/_index.md`) Copy Section

title: "建议" date: 2018-11-15T12:32:37+08:00 weight: 9 Copy Chapter

Articles Sonarqube For Golang Index (`content/articles/sonarqube-for-golang/index.md`) Copy Section

title: Golang 代码质量持续检测 date: 2018-07-22T00:00:00+08:00 Copy Chapter

Author: Kenny Allen

Email: [email protected]

前言 Copy Chapter

在软件开发过程中，人工检查项目代码中的漏洞和潜在的 BUG 是一件让人十分费神费力的事情，为了解决这一痛点，SonarQube诞生了，它实现了一系列代码自动检测过程，包括命名规范，代码漏洞，代码重复量等。

但是光有 SonarQube 还不能发挥出应有的高效率，一个完整的代码质量持续检测应配合代码仓库(如 gitlab) 和 Jenkins 来共同构建一个自动化过程。

环境 Copy Chapter

• Gitlab、Jenkins、SonarQube 服务都在一台物理机上的Docker中运行

• 网络 (局域网IP：192.168.1.100)

• 主机科学上网代理

  192.168.1.100:1087

• 模拟外网访问

  shell Copy

  # 修改 hosts 文件，模拟外网访问
  sudo sh -c "echo '192.168.1.100 jenkins.kenny.com\n192.168.1.100 gitlab.kenny.com\n192.168.1.100 sonarqube.kenny.com' >> /etc/hosts"

• 工具集

搭建 Copy Chapter

接下来，我以一个完整的案例来介绍搭建过程。

Jenkins Copy Section

启动服务

# $jenkins_home 宿主机目录，挂载容器 /var/jenkins_home
# 我的数据卷目录是 ~/.jenkins
export JENKINS_HOME=~/.jenkins
docker run -d --restart=always -p 8080:8080 -p 50000:50000 -v $JENKINS_HOME:/var/jenkins_home --name jenkins jenkins:2.60.3

# 查看 jenkins 日志
docker logs -f jenkins

初始化

1. 打开浏览器，访问 http://jenkins.kenny.com:8080

   shell Copy

   # 在日志中找到管理员密码
   docker logs -f jenkins 
   
   # 或者在 $JENKINS_HOME/secrets/initialAdminPassword 文件中找到管理员密码
   cat $JENKINS_HOME/secrets/initialAdminPassword

2. 安装推荐插件 (如果你想自定义安装插件，点击 Select plugins to Install)

3. 创建管理员账号

4. 初始化完成

Gitlab Copy Section

启动服务 (gitlab 集成的服务比较多，因此需要占用较大的内存，官方推荐4GB以上)

# $gitlab_home 宿主机目录
# 我的数据卷目录是 ~/.gitlab
export GITLAB_HOME=~/.gitlab
docker run -d --restart=always -e 'GITLAB_HOST=gitlab.kenny.com' -p 443:443 -p 80:80 -p 22:22 -v $GITLAB_HOME/conf:/etc/gitlab -v $GITLAB_HOME:/var/opt/gitlab -v $GITLAB_HOME/log:/var/log/gitlab --name gitlab gitlab/gitlab-ce:11.1.0-ce.0

# 查看 gitlab 日志
docker logs -f gitlab

初始化

1. 打开浏览器，访问 http://gitlab.kenny.com

2. 设置新密码后，使用 root 用户登录

3. 新建 sonarqube 项目组

4. 在 sonarqube 项目组下新建 demo 项目

5. 添加主机公钥到 Gitlab

   shell Copy

   # 生成 rsa 公钥和密钥
   ssh-keygen -t rsa
   
   # 查看并复制公钥
   cat ~/.ssh/id_rsa.pub

   访问 http://gitlab.kenny.com/profile/keys ，将公钥添加至 Gitlab

6. 将 sonarqube/demo 项目拉至主机的 $GOPATH 下

   shell Copy

   # 在 $GOPATH 下创建 gitlab.kenny.com 文件夹
   mkdir -p $GOPATH/src/gitlab.kenny.com && cd $GOPATH/src/gitlab.kenny.com
   
   # clone code
   git clone [email protected]:sonarqube/demo.git

SonarQube Copy Section

启动服务

# 由于目前 sonarqube 官方的 Docker images 只有 7.1 版本，不满足 SonarGO 所需 7.2+ 版本，所以我参考7.1 的 Dockerfile 制作了一个 sonarqube 7.2.1 的镜像
# $sonarqube_home 宿主机目录
# 我的数据卷目录是 ~/.sonarqube
export SONARQUBE_HOME=~/.sonarqube
# 正式环境中应启用外部数据库服务来存储必要数据，在启动容器时设置如下JDBC相关参数:
# -e SONARQUBE_JDBC_USERNAME=sonar 
# -e SONARQUBE_JDBC_PASSWORD=sonar 
# -e SONARQUBE_JDBC_URL=jdbc:postgresql://localhost/sonar
docker run -d --restart=always -p 9000:9000 -v $SONARQUBE_HOME:/opt/sonarqube/data --name sonarqube kennyallen/sonarqube:7.2.1

# 查看 sonarqube 日志
docker logs -f sonarqube

文件：Dockerfile、run.sh

初始化

1. 打开浏览器，访问 http://sonarqube.kenny.com:9000

2. 使用管理员账号登录

   • 账号 admin
   • 密码 admin

3. 生成 token (作为远程连接 SonarQube 的标识，只生成一次，记得备份哦)

   admin_token: 74439d5bc557dcc206fa8b1f2f5516e65680bdc8

4. 安装插件 (进入 Administration -> Marketplace)

   安装完成后点击重启 SonarQube 服务就OK了

集成 Copy Chapter

• 将 Jenkins、Gitlab 和 SonarQube 有机整合

Jenkins 安装插件 Copy Section

1. 点击进入 系统管理 -> 插件管理 -> 可选插件

2. 过滤选中 Gitlab、SonarQube Scanner，点击下载待重启后安装

Jenkins 配置 Copy Section

1. 安装 SonarQube & JDK

   进入 系统管理 -> Global Tool Configuration

   JDK 安装

   ​ 勾选我同意 Java SE Development Kit 的许可协议

   ​ 点击 Please enter your username/password

   输入你的 oracle 账号密码

   SonarQube Scanner 安装

   点击保存。

2. SonarQube Server

   进入 系统管理 -> 系统设置

   Add SonarQube servers

   Name 随便填写

   Server URL: http://sonarqube.kenny.com:9000

   Server version: 5.3 or higher

   Server authentication token: 填 SonarQube 初始化时生成的 token

3. 取消 Gitlab 授权

   取消选中 Enable authentication for '/project' end-point，保存

4. 在 jenkins 容器中安装 golang 环境及工具

   shell Copy

   # 在 Jenkins 容器中执行命令
   docker exec -it jenkins /bin/bash
   # 临时设置环境变量
   export GOROOT=$JENKINS_HOME/go
   export GOPATH=$JENKINS_HOME/workspace/go
   export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
   export http_proxy=http://192.168.1.100:1087;export https_proxy=http://192.168.1.100:1087;
   # 进入 jenkins 主目录
   cd $JENKINS_HOME
   # 下载 golang
   wget https://dl.google.com/go/go1.10.3.linux-amd64.tar.gz
   # 解压 golang 包
   tar -xvf  go1.10.3.linux-amd64.tar.gz
   # 删除 golang 包
   rm go1.10.3.linux-amd64.tar.gz
   # 安装必要工具
   # vgo
   go get -u -v golang.org/x/vgo
   # gometalinter
   go get -u -v github.com/alecthomas/gometalinter
   gometalinter --install

5. 配置邮件通知

   进入 系统管理 -> 系统设置

   Jenkins Location

   系统管理员邮件地址修改为你自己的邮箱地址，如 [email protected]

   Extend E-mail Notification

   SMTP Server 填写对应的SMTP服务地址，如 smtp.163.com

   点击高级，勾选使用SMTP认证

   用户名 注意不需要加 @xxx.xxx

   密码 填写自己的邮箱密码或授权码

   Default Triggers 选中 Always

新建 Jenkins 构建任务 Copy Section

1. 新构建一个自由风格的软件项目

2. 使用自定义的工作空间

   点击高级，勾选使用自定义的工作空间

   目录：$JENKINS_HOME/workspace/go/src/gitlab.kenny.com/demo

3. 源码管理

   Repository URL：http://gitlab.kenny.com/sonarqube/demo

   Credentials：点击Add ，添加凭据 (Gitlab 用户名密码或 SSH登录等方式都可以)

4. 构建触发器，选中

   Build when a change is pushed to GitLab. GitLab webhook URL: http://jenkins.kenny.com:8080/project/demo

   Enabled GitLab triggers 选中 Push Events 和 Accepted Merge Request Events ，表示当 Gitlab 有 push 或 merge 操作发生时触发构建。

5. 新建 webhook

   在浏览器中打开 http://gitlab.kenny.com/admin/application_settings (请使用 root 登录)，找到 Outbound requests ，点击 Expand 后，选中 Allow requests to the local network from hooks and services 并保存更改。 (允许本地网络的 githook)

   进入 http://gitlab.kenny.com/sonarqube/demo/settings/integrations

   URL: http://jenkins.kenny.com:8080/project/demo

   SecretToken: 不填

   选中 Push events、Merge request events

   取消选中 Enable SSL verification

   点击 Add web hook

6. 增加构建步骤，选中 Execute Shell

   shell Copy

   #!/bin/bash
   # 环境变量
   export GOROOT=$JENKINS_HOME/go
   export GOPATH=$JENKINS_HOME/workspace/go
   export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
   export http_proxy=http://192.168.1.100:1087;export https_proxy=http://192.168.1.100:1087;
   
   # 安装依赖
   vgo mod -vendor
   
   # coverage
   go test ./... -coverprofile=coverage.out
   
   # test
   go test ./... -json > report.json
   
   # vet
   go vet ./... 2> govet-report.out
   
   # golint
   golint ./... > golint-report.out
   
   # gometalinter 
   # 执行 gometalinter 会失败,因此加了 || true
   gometalinter ./... > gometalinter-report.out || true

7. 增加构建步骤，选中 Execute SonarQube Scanner

   Analysis properties

   properties Copy

   sonar.projectKey=gitlab.kenny.com
   sonar.projectName=demo
   sonar.sources=.
   sonar.exclusions=**/*_test.go,**/vendor/**
   sonar.tests=.
   sonar.test.inclusions=**/*_test.go
   sonar.test.exclusions=**/vendor/**
   sonar.go.coverage.reportPaths=coverage.out
   sonar.go.tests.reportPaths=report.json
   sonar.go.govet.reportPaths=govet-report.out
   sonar.go.golint.reportPaths=golint-report.out
   sonar.go.gometalinter.reportPaths=gometalinter-report.out

8. 增加构建后操作，选中 Editable Email Notification

   Project Recipient List 填写接收邮件的Email地址，或使用默认配置

   Default Content 加上 SonarQube URL: http://sonarqube.kenny.com:9000

测试 Copy Chapter

# clone demo 代码
cd $GOPATH/src/gitlab.kenny.com && git clone [email protected]:yuhao5/sonarqube-golang.git && rm -rf demo && mv sonarqube-golang demo && cd demo
# push 代码，触发 Jenkins 任务进行自动构建
git remote add gitlab [email protected]:sonarqube/demo.git
git push -u gitlab master

# 若 gitlab 仓库地址不是 [email protected]:sonarqube/demo.git ，请根据以下步骤修改：
docker exec -it gitlab /bin/bash
vim /etc/gitlab/gitlab.rb
# 找到 external_url，修改为 external_url 'http://gitlab.kenny.com'
# 然后执行
gitlab-ctl reconfigure

TODO Copy Chapter

1. 解决执行 gometalinter 失败问题
2. Golang 质量标准，规则自定义
3. ...

Home (`content/home.md`) Copy Section

date: 2018-11-08T21:07:13+01:00 last_date: 2020-03-05T15:08:00+08:00 title: Go 夜读 type: index weight: 0 Copy Chapter

加入方法 Copy Chapter

微信 Copy Section

微信搜索 night_reading_go ，添加好友，备注你的姓名、公司、工作岗位和职责，
来自：Github，我会拉你入群。

订阅 Go 夜读微信公众号：

YouTube, Twitter, Facebook, Telegram, Slack Copy Section

我们的精神 Copy Chapter

开源！开源！开源！

重要的事，一定要说三遍。

希望有兴趣的小伙伴们一起加入，让我们一起把 『Go 夜读』建立成一个对大家都有帮助的开源社区。

我们的目标 Copy Chapter

我们希望可以推进大家深入了解 Go ，快速成长为资深的 Gopher 。
我们希望每次来了的人和没来的人都能够有收获，成长。

让每个想要学习的人都能参与进来，（包括初中高级 Go 工程师），
只有层次相当的人才有可能有思维的碰撞和交流，这样最终的产出也尽可能的高质量。

主题内容 Copy Chapter

Go 夜读将定期进行与 Go 语言相关的话题分享，例如源码阅读、工程实践等等，你如果是 Go 新手可以先去这里查看 Go 学习之路。

我们的选题范围 Copy Section

我们的选题范围包括但不限于：

• 入门级
• 实操级
• 架构设计级
• 学习方法、习惯培养等
• 效率效能提升
• 论文研讨

我们的基本流程和分享方式 Copy Section

1. 通过提交 Issue 的方式来收集大家想要研究的与 Go 相关的源码库或源码模块等话题；
2. 提交的话题提案必须得到得到 SIG 小组的批准，并成功招募到分享人，该分享才会进入准备阶段。同样欢迎自荐话题并主动进行分享；
3. 分享人准备分享材料，并在材料准备完毕后交付 SIG 小组审阅；
4. 当 SIG 小组完成对材料的审阅后，将进行正式排期（这期间包括划定受众范围、审阅任务分工、分发排期计划等）；
5. 正式在线上进行分享；
6. 将视频进行后期剪辑并上传至视频网站，再进行后续分发。

回看地址 Copy Section

• Go 夜读（YouTuBe）
• Go 夜读（Bilibili）
• Go 夜读（腾讯视频）

往期分享 Copy Section

见 GitHub 项目主页。

Go 夜读 SIG 小组 Copy Chapter

SIG 的全称是 Special Interests Group, 或称 Super Intellectual Genius。
Go 夜读 SIG 小组负责 Go 夜读活动的日常维护，目前的核心成员包括：

• 杨文 yangwenmai
• 欧长坤 changkun
• FelixSeptem
• 饶全成 qcrao
• 煎鱼 - EDDYCJY

想要加入？参考如何加入 Go 夜读 SIG 小组。

如何发起分享提案？ Copy Chapter

你是否经常困扰于某些 Go 话题没有人分享或者很少人关注？自己很想深入研究，但是却是形单影只，经常半途而废呢？

机会来了！！！参考如何发起分享提案

如何参与贡献？ Copy Chapter

想要参与贡献？阅读 如何参与贡献 查看指南。

Stargazers over time Copy Chapter

night-reading-go Star History and Stats

Contributors Copy Chapter

我非常重视每一个对这个项目的贡献者，我会将贡献者列表更新到这里，目前只有提交 Pull Request 的小伙伴，但是贡献不仅仅如此，还可以包括提交 Issue 以及在社群中有所贡献的人。

贡献者自己可以提 PR ，方法如下：

• 安装 npm install --save-dev all-contributors-cli
• sh gen_contributors.sh

贡献类型有多种，比如："code", "ideas","review","talk","tutorial"，你可以在 .all-contributorsrc 中修改。

Thanks goes to these wonderful people (emoji key):

This project follows the all-contributors specification. Contributions of any kind welcome!

Algorithms 2020 12 27 (`content/algorithms/2020-12-27.md`) Copy Section

title: 2020-12-27 TalkGo 算法之美微信群今日讨论问题 date: 2020-12-27T22:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2020-12-27

算法之美微信群当日讨论列表 Copy Chapter

1. Leetcode双周赛第四题：得到连续 K 个 1 的最少相邻交换次数
   原题链接：https://leetcode-cn.com/problems/minimum-adjacent-swaps-for-k-consecutive-ones/
2. Q30 用插线板制作章鱼脚状线路
   原题链接：https://leetcode-cn.com/leetbook/read/interesting-algorithm-puzzles-for-programmers/9l2pjv/

TalkGo 算法之美专栏更新 Copy Chapter

1. AK F.*ing leetcode 流浪计划
2. AK F.*ing leetcode 流浪计划之并查集

Algorithms 2020 12 28 (`content/algorithms/2020-12-28.md`) Copy Section

title: 2020-12-28 TalkGo 算法之美第三期第一周第一阶段 date: 2020-12-28T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2020-12-28

周一题目的链接：https://talkgo.org/t/topic/1443

主题：树的构造 Copy Chapter

先重温下二叉树是怎么构造出来的吧 Copy Section

108. 将有序数组转换为二叉搜索树

附加题： Copy Section

95. 不同的二叉搜索树 II

• Tips: 递归

Algorithms 2020 12 29 (`content/algorithms/2020-12-29.md`) Copy Section

title: 2020-12-29 TalkGo 算法之美第三期第一周第二阶段 date: 2020-12-29T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2020-12-29

• 2020.12.29
  TalkGo算法之美群今日讨论问题

  1. 将有序数组转换为二叉搜索树
     题目链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/
     题解链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/108-jiang-you-xu-shu-zu-zhuan-huan-wei-e-muuy/（来源：木头（算法之美群内成员））

  2. 不同的二叉搜索树 II
     原题链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii/
     题解链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii/solution/95-bu-tong-de-er-cha-sou-suo-shu-ii-di-g-qu38/（来源：木头（算法之美群内成员））

  关于如何建设好算法之美群：
  吴俊伟：我觉得可以分两类人，一种是为了找工作而刷题的，一种是单纯为了学习算法。对于前一种可以多找些高频面试题，后一种就按照现在来就好了。提高参与度的话就让大家可以把自己觉得好的题目或者做不出来的题目，又或者是面试遇到的题目发出来让大家看看，一起讨论。
  吴俊伟：还有平台可以不用局限leetcode，洛谷，计蒜客，牛客网，poj都行的
  小林：可以发布一些算法比赛消息
  吴俊伟：不过我们也可以照顾到这些人多发些面试常考的"经典"题

Algorithms 2020 12 30 (`content/algorithms/2020-12-30.md`) Copy Section

title: 2020-12-30 TalkGo 算法之美第三期第一周第二阶段 date: 2020-12-30T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2020-12-30

• 2020.12.30
  TalkGo算法之美群今日讨论问题
  1. 算法之美第三期周三题目
     原题链接以及群友题解（题解见评论）：https://talkgo.org/t/topic/1443
  2. 比赛消息
     由群成员吴俊伟提供
     牛客2020跨年场
     比赛时间：2020-12-31 21:00:00 - 2021-01-01 00:30:00
     比赛地址：https://ac.nowcoder.com/acm/contest/9854

Algorithms 2021 01 01 (`content/algorithms/2021-01-01.md`) Copy Section

title: 2021-01-01 TalkGo 算法之美第三期第一周第三阶段
date: 2021-01-01T08:31:00+08:00

来源：『TalkGo 算法之美』微信群

时间：2021-01-01

• 2021.1.1
  TalkGo算法之美群今日讨论要素

  1. 算法之美第三期第一周周五题目链接：https://talkgo.org/t/topic/1443
  2. leetcode435. 无重叠区间 （由群友木头提供）
     原题链接：https://leetcode-cn.com/problems/non-overlapping-intervals/
  3. 群友roseduan分享刷题记录
     链接：https://github.com/roseduan/algo-learn
  4. 本周线上讨论会预定于明天（2020.1.2）下午两点举行，欢迎各位来参与讨论。

Algorithms 2021 01 03 (`content/algorithms/2021-01-03.md`) Copy Section

title: 2021-01-03 TalkGo 算法之美第三期第一周第三阶段 date: 2021-01-03T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-03

• 2021.1.3
  TalkGo算法之美群今日讨论要素

1. leetcode周赛：https://leetcode-cn.com/contest/weekly-contest-222/

2. leetcode每日一题： 86. 分隔链表
   原题链接：https://leetcode-cn.com/problems/partition-list/

Algorithms 2021 01 06 (`content/algorithms/2021-01-06.md`) Copy Section

title: 2021-01-06 TalkGo 算法之美第三期第二周第三阶段 date: 2021-01-06T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-06

• 2021.01.06
• TalkGo算法之美第三期第二周开始啦。
  以下是周三题目的链接：https://talkgo.org/t/topic/1502
  主题：二叉搜索树

Algorithms 2021 01 08 (`content/algorithms/2021-01-08.md`) Copy Section

title: 2021-01-08 TalkGo 算法之美第三期第二周第三阶段 date: 2021-01-08T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-08

• 2021.01.08
• TalkGo算法之美第三期第二周开始啦。
  以下是周五题目的链接：https://talkgo.org/t/topic/1502
  主题：巧用遍历

Algorithms 2021 01 09 (`content/algorithms/2021-01-09.md`) Copy Section

title: 2021-01-09 TalkGo 算法之美第三期第三周第二阶段 date: 2021-01-09T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-9

• 2021.10.9
• TalkGo算法之美群今日讨论要素
  1. leecode每日一题：123. 买卖股票的最佳时机 III
     链接:https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/

Algorithms 2021 01 11 (`content/algorithms/2021-01-11.md`) Copy Section

title: 2021-01-11 TalkGo 算法之美第三期第三周第一阶段 date: 2021-01-11T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-11

• 2021.1.11
• TalkGo算法之美第三期第三周开始啦。
  以下是周一题目的链接：https://talkgo.org/t/topic/1550
  主题：回溯

Algorithms 2021 01 12 (`content/algorithms/2021-01-12.md`) Copy Section

title: 2021-01-12 TalkGo 算法之美第三期第三周第二阶段 date: 2021-01-12T08:31:00+08:00 Copy Chapter

来源：『TalkGo 算法之美』微信群

时间：2021-01-12

• 2021.1.12
  TalkGo算法之美群今日讨论要素

  1. 百度面试题（群友bill提供）：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/

  2. 腾讯面试题（群友小林提供）：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

  3. 每日一题题解：https://talkgo.org/t/topic/1561

  4. 面试高频题（群友bill提供）：https://leetcode-cn.top/#/home

Articles 2018 05 31 Batch Del Redis Key (`content/articles/2018-05-31-batch-del-redis-key.md`) Copy Section

title: 批量删除redis中的key date: 2018-05-31T00:00:00+08:00 Copy Chapter

• 1.首先看图

• 1.我创建了三个以go:read开头的key
• 2.通过keys go:read:*可以全部找出来
• 3.接下来退出redis-cli,使用redis-cli -p 6379 keys "go:read*" | xargs redis-cli -p 6379 del可以批量删除

• 2.查看原理

• 1.执行redis-cli -p 6379 keys "go:read*"控制台输出了需要的key
• 2.执行redis-cli -p 6379 keys "go:read*" | xargs -0 echo,可以看到输出了需要的key，但是有点不一样，双引号被去掉了,这说明数据通过管道传递给了xargs作了相应处理
• 3.执行redis-cli -p 6379 keys "go:read*" | xargs redis-cli -p 6379 del删除了输出的key,这说明xargs对接收到数据分别进行了redis-cli -p 6379 del操作

• 3.遇到的问题

• 1.同样的原理，我设置了三个key，但是这三个key里面包含了双引号,双引号前得加上\转义符
• 2.使用redis-cli -p 6379 keys "go:read*" | xargs redis-cli -p 6379 del,发现没删除
• 3.通过redis-cli -p 6379 keys "go:read*" | xargs -0 echo,发现传输到xargs时把\转义符删掉了，去执行redis del操作的时候key不配，导致删除失败
• TODO 采用xargs我没找到解决方案，希望各位大神求助,有方法了可以写在下面@～@

• 4.另一种解决方案

• for i in $(redis-cli -p 6379 keys "go:read:*");do redis-cli -p 6379 del "$i";done
• 采用shell脚本格式 -> for循环读取key去删除

Articles 2018 11 11 Golang File Lock (`content/articles/2018-11-11-golang-file-lock.md`) Copy Section

title: golang 的文件锁操作 date: 2018-11-11T00:00:00+08:00 Copy Chapter

这篇文章给大家介绍一下 golang 的文件锁。我们在使用 golang 开发程序的时候，经常会出现多个 goroutine 操作同一个文件（或目录）的时候，如果不加锁，很容易导致文件中的数据混乱，于是，Flock 应运而生。

Flock 是对于整个文件的建议性锁（不强求 goroutine 遵守），如果一个 goroutine 在文件上获取了锁，那么其他 goroutine 是可以知道的。默认情况下，当一个 goroutine 将文件锁住，另外一个 goroutine 可以直接操作被锁住的文件，原因在于 Flock 只是用于检测文件是否被加锁，针对文件已经被加锁，另一个 goroutine 写入数据的情况，内核不会阻止这个 goroutine 的写入操作，也就是建议性锁的内核处理策略。

函数 Copy Chapter

import "syscall"

func Flock(fd int, how int) (err error)

Flock 位于 syscall 包中，fd 参数指代文件描述符，how 参数指代锁的操作类型。

how 主要的参数类型：

• LOCK_SH，共享锁，多个进程可以使用同一把锁，常被用作读共享锁；
• LOCK_EX，排他锁，同时只允许一个进程使用，常被用作写锁；
• LOCK_NB，遇到锁的表现，当采用排他锁的时候，默认 goroutine 会被阻塞等待锁被释放，采用 LOCK_NB 参数，可以让 goroutine 返回 Error;
• LOCK_UN，释放锁；

示例 Copy Chapter

下面的例子来自于 NSQ，位于 nsq/internal/dirlock，用于实现对目录的加锁

// +build !windows

package dirlock

import (
	"fmt"
	"os"
	"syscall"
)

// 定义一个 DirLock 的struct
type DirLock struct {
	dir string    // 目录路径，例如 /home/XXX/go/src
	f   *os.File  // 文件描述符
}

// 新建一个 DirLock
func New(dir string) *DirLock {
	return &DirLock{
		dir: dir,
	}
}

// 加锁操作
func (l *DirLock) Lock() error {
	f, err := os.Open(l.dir) // 获取文件描述符
	if err != nil {
		return err
	}
	l.f = f
	err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB) // 加上排他锁，当遇到文件加锁的情况直接返回 Error
	if err != nil {
		return fmt.Errorf("cannot flock directory %s - %s", l.dir, err)
	}
	return nil
}

// 解锁操作
func (l *DirLock) Unlock() error {
	defer l.f.Close() // close 掉文件描述符
	return syscall.Flock(int(l.f.Fd()), syscall.LOCK_UN) // 释放 Flock 文件锁
}

总结 Copy Chapter

1. Flock 是建议性的锁，使用的时候需要指定 how 参数，否则容易出现多个 goroutine 共用文件的问题
2. how 参数指定 LOCK_NB 之后，goroutine 遇到已加锁的 Flock，不会阻塞，而是直接返回错误

Articles 2019 11 07 Raft 易于理解的一致性算法 (`content/articles/2019-11-07-Raft--易于理解的一致性算法.md`) Copy Section

title: Raft--易于理解的一致性算法 date: 2019-11-07T00:00:00+23:00 Copy Chapter

这篇文章讲解如何用 go 实现 raft 算法，代码框架来自于 Mit6.824分布式课程

最初，为了学习分布式系统，我了解到了 Mit 6.824课程，课程的 lab 需要用 go 来完成。于是 go 走进了我的世界，go 很容易入门， 写起来很舒服，但是要真正的理解 go， 并不是很容易， 特别是对 goroutine, select, channel 等的灵活运用。俗话说的好，初生牛犊不怕虎， 在初步了解 go 之后， 我就开始学习课程了。 每个 lab 都会有对应的论文， 比如 mapreduce, raft 等等。 lab2 是实现 raft 算法， lab3 是基于 lab2的 raft 算法来 实现一个简单的分布式 kv 存储。 在做 lab 的过程中，不仅仅可以对 raft 的细节有更好的把握, 同时对 go 语言的理解也会逐渐加深， 特别是并发部分。

首先看一下复制状态机,如下图所示

复制状态机通常是基于复制日志实现的。每一台服务器存储着一个包含一系列指令的日志，每个日志都按照相同的顺序包含相同的指令，所以每一台服务器都执行相同的指令序列。那么如何保证每台服务器上的日志都相同呢？ 这就是接下来要介绍的一致性算法raft要做的事情了。

raft 主要分三大部分， 领导选举， 日志复制， 日志压缩。 由于其中的细节很多，所以在实现过程中肯定会遇到各种各样的问题， 这也是一个比较好的事情，因为问题将促使我们不断地深入的去阅读论文， 同时锻炼 debug 并发程序的能力。最后肯定是满满的收获。

实现主要依赖于raft论文中的下图

代码框架条理清楚。主要包含七个主要的 struct , 三个 RPC handler , 四个主干函数 , 如下

/* Detailed source-code truncated for AI context efficiency. */

下面的部分, 记录了三大部分的主干和我认为的容易出错的地方。

领导选举 Copy Section

1. electForLeader 函数主干，候选人针对每一个 peer 发送请求投票RPC

for i:=0; i<len(rf.peers); i++ {
    // meet myself
    if i==rf.me {
        continue
    }
    go func(index int) {
        reply := &RequestVoteReply{}
        response := rf.sendRequestVote(index, &args, reply)
        if response {
            ...
        }
    }(i)
}

2. 获得响应后，要将 reply 的 term 于 candidate 的 currentTerm 进行比较

if reply.Term > rf.currentTerm {
    rf.currentTerm = reply.Term
    rf.changeRole("follower")
    return
}

3. 获得响应后，候选人要检查自己的 state 和 term 是否因为发送RPC而改变

if rf.state != "candidate" || rf.currentTerm!= args.Term { return }

4. 若候选人获得的投票超过半数，则变成领导人

5. 请求投票PRC ⭐(接收者指接收 请求投票PRC 的 peer)

• 如果 candidate 的 term 小于接收者的 currentTerm， 则不投票，并且返回接收者的 currentTerm

  go Copy

  reply.VoteGranted = false
  reply.Term = rf.currentTerm
  if rf.currentTerm > args.Term { return }

• 如果接收者的 votedFor 为空或者为 candidateId，并且 candidate 的日志至少和接收者一样新，那么就投票给候选人。candidate 的日志至少和接收者一样新的含义：candidate 的最后一个日志条目的 term 大于接收者的最后一个日志条目的 term 或者当二者相等时，candidate 的最后一个日志条目的 index 要大于等于接收者的

  go Copy

  if (rf.votedFor==-1 || rf.votedFor==args.CandidateId) &&
     (args.LastLogTerm > rf.getLastLogTerm() ||
   ((args.LastLogTerm==rf.getLastLogTerm())&& (args.LastLogIndex>=rf.getLastLogIndex()))) {
         reply.VoteGranted = true
         rf.votedFor = args.CandidateId
         rf.state = "follower"   // rf.state can be follower or candidate
         ...
  }

日志复制 Copy Section

1. appendLogEntries 函数的主干，leader 针对每一个 peer 发送附加日志 RPC

for i:=0; i<len(rf.peers); i++ {
    if i == rf.me {
        continue
    }
    go func(index int) {
        reply := &AppendEntriesReply{}
        respond := rf.sendAppendEntries(index, &args, reply)
        if reply.Success {
            ...
            return
        } else {
            ...
        }
    }(i)
}

2. 获得响应后，要将 reply 的 term 于 leader 的 currentTerm 进行比较

3. 获得响应后，候选人要检查自己的 state 和 term 是否因为发送RPC 而改变

4. 回复成功

• 更新 nextIndex, 即 leader 需要发送给该 peer 下一条日志条目的索引值 , 更新 matchIndex, 即 leader 已经复制给该 peer 的日志的最高索引值

  go Copy

  rf.matchIndex[index] = args.PrevLogIndex + len(args.Entries)
  rf.nextIndex[index] = rf.matchIndex[index] + 1

• 如果存在一个 N 满足 N>commitIndex，并且大多数 matchIndex[i] > N 成立，并且 log[N].term == currentTerm，则更新 commitIndex=N

5. 回复不成功

• 更新 nextIndex，然后重试

6. 附加日志RPC ⭐

• 几个再次明确的地方：

  • preLogIndex 的含义：新的日志条目(s)紧随之前的索引值，是针对每一个follower而言的==nextIndex[i]-1，每一轮重试都会改变。

  • entries[] 的含义：准备存储的日志条目；表示心跳时为空

    go Copy

    append(make([]LogEntry, 0), rf.log[rf.nextIndex[index]-rf.LastIncludedIndex:]...)

• 领导人获得权力后，初始化所有的 nextIndex 值为自己的最后一条日志的 index+1；如果一个 follower 的日志跟领导人的不一样，那么在附加日志 PRC 时的一致性检查就会失败。领导人选举成功后跟随者可能的情况

• reply增加 ConflictIndex 和 ConflictTerm 用于记录日志冲突 index 和 term

• 如果 leader 的 term 小于接收者的 currentTerm， 则 reply false.

• 接下来就三种情况 ⭐(比较绕且容易出错)

  1. follower 的日志长度比 leader 的短, 那么 ConflictIndex 就是 follower 的 日志长度。之后在 appendLogEntries 函数里面会更新 nextIndex 为 ConflictIndex, 相应的 prevLogIndex 也会改变, 于是在下一轮RPC中便可以比较 follower 的日志条目在 arg.PrevLogIndex 索引处的 Term 是否等于 args.PrevLogTerm, 如果相等, 则该可以把 leader 在 arg.PrevLogIndex 后面的一次性全部添加到 follower 的日志条目上, 从而达成一致性, 否则令 ConflictTerm 为 follower 的日志条目在 arg.PrevLogIndex 索引处的 Term, 然后从头遍历 follower 的日志条目, 找到第一个 term 等于 ConflictTerm 的 索引, 用来更新 ConflictIndex
  2. follower 的日志长度比 leader 的长，且在 prevLogIndex 处的 term 相等, 则开始依次对比 follower 在 arg.prevLogIndex 后的日志条目在何处跟 entries 上相应的日志的 term 不一致, 假设该索引为 idx, 那么 follower 在索引后的日志条目应该被替换为 entries 在 该索引后的日志条目, 最终达成一致性
  3. follower 的日志长度比 leader 的长，且在 prevLogIndex 处的 term 不相等, 之后便是去寻找 ConflictTerm 然后更新 ConflictIndex, 直到在 prevLogIndex 处的 term 相等, 然后按照 2 进行处理.
  go Copy

  if args.PrevLogIndex >=rf.LastIncludedIndex && args.PrevLogIndex < rf.logLen() {
      if args.PrevLogTerm != rf.log[args.PrevLogIndex-rf.LastIncludedIndex].Term {
          reply.ConflictTerm = rf.log[args.PrevLogIndex-rf.LastIncludedIndex].Term
          //  then search its log for the first index
          //  whose entry has term equal to conflictTerm.
          for i:=rf.LastIncludedIndex; i<rf.logLen(); i++ {
              if rf.log[i-rf.LastIncludedIndex].Term==reply.ConflictTerm {
                  reply.ConflictIndex = i
                  break
              }
          }
          return
      }
  }else {
      reply.ConflictIndex = rf.logLen()
      return
  }
  
  index := args.PrevLogIndex
  for i:=0; i<len(args.Entries); i++ {
      index++
      if index >= rf.logLen() {
          rf.log = append(rf.log, args.Entries[i:]...)
          rf.persist()
          break
      }
      if rf.log[index-rf.LastIncludedIndex].Term != args.Entries[i].Term {
          rf.log = rf.log[:index-rf.LastIncludedIndex]
          rf.log = append(rf.log, args.Entries[i:]...)
          rf.persist()
          break
      }
  }

• 如果 leaderCommit > commitIndex，令 commitIndex 等于 leaderCommit 和新日志条目索引值中较小的一个

日志压缩 Copy Section

1. 采用日志压缩，不仅可以减少本地占用的空间和每次重置的时间花销, 还可以直接通过网络把快照发给那些落后的跟随者，使他们更新到最新的状态

2. 下图为 Raft 中快照的基本思想, 快照中包含状态机的状态, LastIncludeIndex: 被快照取代的最后的条目在日志中的索引值, LastIncludedTerm: 该条目的任期号,保留这些数据是为了支持快照后紧接着的第一个条目的附加日志请求时的一致性检查

3. 安装快照RPC

• 尽管服务器通常都是独立的创建快照，但是领导人必须偶尔的发送快照给一些落后的跟随者

• 三种情况

  • leader 的 LastIncludedIndex 小于等于 follower 的 LastIncludeIndex
  • leader 的 LastIncludedIndex 大于 follower 的 LastIncludeIndex，leader 的 LastIncludedIndex 小于 follower 日志的最大索引值
  • leader 的 LastIncludedIndex 大于等于 follower 日志的最大索引值

  对应的处理方式

  • 如果接收到的快照是自己日志的前面部分，那么快照包含的条目将全部被删除，但是快照后面的条目仍然有效，要保留
  • 如果快照中包含没有在接收者日志中存在的信息，那么跟随者丢弃其整个日志，全部被快照取代。

总结 Copy Section

1. 个人认为看一两遍论文就掌握 raft 还是比较困难的, 所以当对 raft 有了大致了解之后, 就可以开始实现了, 遇到问题后带着问题去读, 反复咀嚼, 逐渐加深对 raft 的理解

2. 推荐看一下这个: raft 可视化, 可以对 raft 有一个直观的感受

Articles 2020 02 08 Source Go Flag (`content/articles/2020-02-08-source_go_flag.md`) Copy Section

title: "Go 源码阅读之 flag 包" date: 2020-02-08T17:54:04+08:00 Copy Chapter

• 简介
• 文件结构
• 运行测试
• 总结
  • 接口转换能实现类似 C++ 中模板的功能
  • 函数 vs 方法
  • new vs make
  • 指针赋值给接口变量
  • flag文件夹中有flag_test包
  • 作用域
• 参考文献

简介 Copy Chapter

flag 包是 Go 里用于解析命令行参数的包。为什么选择它作为第一个阅读的包，因为它的代码量少。其核心代码只有一个 1000 不到的 flag.go 文件。

文件结构 Copy Chapter

flag 包的文件结构很简单，就一层。一个文件夹里放了 5 个文件，其文件及其作用如下：

• flag.go

  flag 的核心包，实现了命令行参数解析的所有功能

• export_test.go

  测试的实用工具，定义了所有测试需要的基础变量和函数

• flag_test.go

  flag 的测试文件，包含了 17 个测试单元

• example_test.go

  flag 的样例文件，介绍了 flag 包的三种常用的用法样例

• example_value_test.go

  flag 的样例文件，介绍了一个更复杂的样例

运行测试 Copy Chapter

我先介绍一下 Go 的运行环境。

# 通过 brew install go 安装，源码位置为 $GOROOT/src
GOROOT=/usr/local/opt/go/libexec
# 阅读的源码通过 go get -v -d github.com/haojunyu/go 下载，源码位置为 $GOPATH/src/github.com
GOPATH=$HOME/go

单独测试 flag 包踩过的坑：

1. 无法针对单个文件进行测试，需要针对包。

这里重点说一下 export_test.go 文件，它是flag包的一部分package flag，但是它确实专门为测试而存在的，说白了也就一个ResetForTesting方法，用来清除所有命令参数状态并且直接设置Usage函数。该方法会在测试用例中被频繁使用。所以单独运行以下命令会报错"flag_test.go:30:2: undefined: ResetForTesting"

# 测试当前目录（报错）
go test -v .
# 测试包
go test -v flag

2. go test -v flag 测试的源码是 $GOROOT/src 下的（以我当前的测试环境）

指定 flag 包后，实际运行的源码是 $GOROOT 下的，这个应该和我的安装方式有关系。

总结 Copy Chapter

接口转换能实现类似 C++ 中模板的功能 Copy Section

flag 包中定义了一个结构体类型叫 Flag，它用来存放一个命令参数，其定义如下。

// A Flag represents the state of a flag.
// 结构体Flag表示一个参数的所有信息，包括名称，帮助信息，实际值和默认值
type Flag struct {
	Name     string // name as it appears on command line名称
	Usage    string // help message帮助信息
	Value    Value  // value as set实现了取值/赋值方法的接口
	DefValue string // default value (as text); for usage message默认值
}

其中命令参数的值是一个 Value 接口类型，其定义如下：

// Set is called once, in command line order, for each flag present.
// The flag package may call the String method with a zero-valued receiver,
// such as a nil pointer.
// 接口Value是个接口，在结构体Flag中用来存储每个参数的动态值（参数类型格式各样）
type Value interface {
	String() string   // 取值方法
	Set(string) error // 赋值方法
}

为什么这么做？因为这样做能够实现类似模板的功能。任何一个类型 T 只要实现了 Value 接口里的 String 和 Set 方法，那么该类型 T 的变量 v 就可以转换成 Value 接口类型，并使用 String 来取值，使用 Set 来赋值。这样就能完美的解决不同类型使用相同的代码操作目的，和 C++ 中的模板有相同的功效。

函数 vs 方法 Copy Section

函数和方法都是一组一起执行一个任务的语句，二者的区别在于调用者不同，函数的调用者是包 package，而方法的调用者是接受者 receiver。在 flag 的源码中，有太多的函数里面只有一行，就是用包里的变量 CommandLine 调用同名方法。

// Parsed reports whether f.Parse has been called.
// Parsed方法： 命令行参数是否已经解析
func (f *FlagSet) Parsed() bool {
	return f.parsed
}

// Parsed reports whether the command-line flags have been parsed.
func Parsed() bool {
	return CommandLine.Parsed()
}

`new` vs `make` Copy Section

new 和 make 是 Go 语言中两种内存分配原语。二者所做的事情和针对的类型都不一样。
new 和其他编程语言中的关键字功能类似，都是向系统申请一段内存空间来存储对应类型的数据，但又有些区别，区别在于它会将该片空间置零。也就是说 new(T) 会根据类型 T 在堆上 申请一片置零的内存空间，并返回指针 *T。
make 只针对切片，映射和信道三种数据类型 T 的构建，并返回类型为 T 的一个已经初始化（而非零）的值。原因是这三种数据类型都是引用数据类型，在使用前必须初始化。就像切片是一个具有三项内容的描述符，包含一个指向数组的指针，长度和容量。通过 make 创建对应类型的变量过程是先分配一段空间，接着根据对应的描述符来创建对应的类型变量。关于 make 的细节可以看 draveness 写的 Go语言设计与实现。

// Bool defines a bool flag with specified name, default value, and usage string.
// The return value is the address of a bool variable that stores the value of the flag.
func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
	p := new(bool)
	f.BoolVar(p, name, value, usage)
	return p
}


// sortFlags returns the flags as a slice in lexicographical sorted order.
// sortFlags函数：按字典顺序排序命令参数，并返回Flag的切片
func sortFlags(flags map[string]*Flag) []*Flag {
	result := make([]*Flag, len(flags))
	i := 0
	for _, f := range flags {
		result[i] = f
		i++
	}
	sort.Slice(result, func(i, j int) bool {
		return result[i].Name < result[j].Name
	})
	return result
}

指针赋值给接口变量 Copy Section

Go 中的接口有两层含义，第一层是一组方法（不是函数）的签名，它需要接受者（具体类型 T 或具体类型指针 *T ）来实现细节；另一层是一个类型，而该类型能接受所有现实该接受的接受者。深入理解接口的概念可以细读 Go语言设计与实现之接口。在 flag 包中的 StringVar 方法中newStringValue(value, p)返回的是 *stringValue 类型，而该类型（接受者）实现了 Value 接口（ String 和 Set 方法），此时该类型就可以赋值给 Value 接口变量。

// StringVar defines a string flag with specified name, default value, and usage string.
// The argument p points to a string variable in which to store the value of the flag.
// StringVar方法：将命令行参数的默认值value赋值给变量*p,并生成结构Flag并置于接受者中f.formal
func (f *FlagSet) StringVar(p *string, name string, value string, usage string) {
	f.Var(newStringValue(value, p), name, usage) // newStringValue返回值是*stringValue类型，之所以能赋值给Value接口是因为newStringValue实现Value接口时定义的接受者为*stringValue
}

flag文件夹中有`flag_test`包 Copy Section

flag 文件夹下有 flag_test 包，是因为该文件夹下包含了核心代码 flag.go 和测试代码 *_test.go 。这两部分代码并没有通过文件夹来区分。所以该 flag_test 包存在的意义是将测试代码与核心代码区分出来。而该包被引用时只会使用到核心代码。

// example_test.go
package flag_test

作用域 Copy Section

关于作用域 Golang变量作用域 和 GO语言圣经中关于作用域 都有了详细的介绍，前者更通俗易懂些，后者更专业些。在 flag 包的 TestUsage 测试样例中，因为 func(){called=true} 是在函数 TestUsage 中定义函数，并且直接作为形参传递给 ResetForTesting 函数，所以该函数是和局部变量 called 是同级的，当然在该函数中给该变量赋值也是合理的。

//  called变量的作用域
func TestUsage(t *testing.T) {
	called := false
	// 变量called的作用域
	ResetForTesting(func() { called = true })
	if CommandLine.Parse([]string{"-x"}) == nil {
		t.Error("parse did not fail for unknown flag")
	} else {
		t.Error("hahahh")
	}
	if !called {
		t.Error("did not call Usage for unknown flag")
	}
}

参考文献 Copy Chapter

1. Go 夜读之 flag 包视频
2. 实效 Go 编程之内存分配
3. Go 语言设计与实现之 make 和 new
4. 菜鸟教程之 Go 语言变量作用域
5. Go 语言圣经中关于作用域
6. Go 语言中值 receiver 和指针 receiver 的对比
7. Go CodeReviewComments
8. Golang 变量作用域
9. Go 语言圣经中关于作用域
10. Go 语言设计与实现之接口

Discuss 2018 05 08 Anlayze Underscore In Go (`content/discuss/2018-05-08-anlayze-underscore-in-go.md`) Copy Section

title: 2018-05-08 Go 语言中下划线的用法分析总结 date: 2018-05-08T00:00:00+08:00 Copy Chapter

讨论时间：2018-05-08 19:25 ~ 2018-05-08 20:00

以下源码分析来源于 Go 夜读微信群的一次代码讨论，我们先来看看这一行代码吧。

...
func (littleEndian) Uint64(b []byte) uint64 {
    _ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
    return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
        uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
}

func (littleEndian) PutUint64(b []byte, v uint64) {
	_ = b[7] // early bounds check to guarantee safety of writes below

	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)
	b[4] = byte(v >> 32)
	b[5] = byte(v >> 40)
	b[6] = byte(v >> 48)
	b[7] = byte(v >> 56) // panic: runtime error: index out of range
}
...

源码可点击 golang/encoding/binary/binary.go

这是 early bounds check to guarantee safety of writes below 注释的 commit。

直译：“早期检查以确保下面的写入安全”。

我们怎么理解这句话呢？

• _可以在编译期检查
• 怎么保证可以做到早期检查呢？
• 如果出现数组越界，会在编译期就不通过。
• 是不是单纯为了如果数组长度不够就提前报错返回，不进行后面的赋值操作了。

不确定究竟是为什么，所以大家还自己写代码来实测验证一下。

寻找答案 Copy Chapter

StackOverflow 有一个一摸一样的问题（他的问题写的非常完整，还给出了另外一种优化，并引发了他的更深刻的思考），以下是 Google 翻译，方便大家查看。

CodeA:

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56) // panic: runtime error: index out of range

    fmt.Println(b)
}

b[7] 是会越界的，但是以上代码是可以通过编译的，只是在执行的时候会报错。

CodeB:

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    b[7] = byte(v >> 56) // panic: runtime error: index out of range
    b[6] = byte(v >> 48)
    b[5] = byte(v >> 40)
    b[4] = byte(v >> 32)
    b[3] = byte(v >> 24)
    b[2] = byte(v >> 16)
    b[1] = byte(v >> 8)
    b[0] = byte(v)

    fmt.Println(b)
}

在一开始 b[7] = byte(v >> 56) 写入数据时就 panic 了。

CodeC:

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    _ = b[7] // early bounds check to guarantee safety of writes below

    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56)

    fmt.Println(b)
}

通过 _ = b[7] 做了早期检查以确保下面的写入安全。

这个问题的作者抛出来两个问题:

• Q1: 在 Golang 中是否有必要进行早期检查以保证书写的安全性？
• Q2: 为了保证书写的安全性进行早期检查的话，哪一个样本代码更简洁和性能优化（速度）好些呢？样本代码A，B，C或...？
  • 作者的回答: 我认为是 B: 因为它简洁并做了早期检查，不是吗？

回答：

问题1：在 Golang 中是否有必要进行早期检查以保证书写的安全性？

A1：这里的答案是“是和否”。一般来说，“否”，你通常不必在Go中插入边界检查，因为编译器会为你插入它们（这就是为什么当你尝试访问片段长度之外的内存位置时，你的示例会 panic）。但是，如果你正在执行多个写入操作（“是”），则需要插入像提供的示例一样的早期边界检查，以确保你不会只有一些写入成功，从而使你处于不良状态（或重构，如你在示例B中所做的那样，以便首次写入最大阵列，确保在任何写入操作成功之前发生恐慌）。

然而，这不是一个“Go 问题”，因为它是一个通用的错误类。在任何语言中如果你不进行边界检查（或者如果它是一种强制执行像 Go 一样的边界的语言的最高索引），写入操作就不安全。这也很大程度上取决于解决方案;在你发布的标准库的示例中，用户进行边界检查是有必要的。但是，在你发布的第二个示例中，用户边界检查不是必需的，因为代码可以像 B 一样写，其中编译器会在第一行插入边界检查。

问题2：为了保证书写的安全性进行早期检查的话，哪一个样本代码更简洁和性能优化（速度）好些呢？样本代码A，B，C或...？

A2：我认为是 B: 因为它简洁并做了早期检查，不是吗？

你是对的。在 B 中，编译器会在第一次写入时插入边界检查，保护其余的写入。因为你正在使用常量（7，6，... 0）对切片进行索引，编译器可以将边界检查从其余的写入中删除，因为它可以保证它们是安全的。

另外一个人的回答：

关于“写入安全性”的评论在这里有误导性。在开始时放置最高边界检查只是一个优化。如果你忽略它，行为将不会改变（或变成“不安全”），但是你可能会遭受多重边界检查而不是仅仅一次的性能损失，因为每个后续较高索引所需的最小限度增量。

如果评论中提到“保证写入安全”，这只是意味着它将保证编译器后续的写入操作是安全的，无需插入更多的边界检查。把它写出来不会使写入不安全，只会让编译器插入更多的边界检查。在任何情况下，编译器都不会产生不安全的内存访问。

在代码中插入这个假的早期边界检查是一个好主意，而不是不使用它或者重写代码来合法使用最高索引（如代码B中的代码），这是值得商榷的。只要它清楚为什么它在那里（例如，一个明智的和没有误导性的评论）我会说如果你想使用它，并找到它的好处。一般情况下，通过手动优化，未来的编译器优化可能会使其成为冗余或以其他方式改变其有效性。

Go 语言中下划线的用法总结 Copy Chapter

用在 import Copy Section

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	_ "net/http/pprof"
)
...

pprof 和 MySQL 是常见用法。

它会引入包，会先调用包中的 init() 函数，这种使用方式仅让导入的包做初始化，而不使用包中其他函数。

往往这些 init() 函数里面注册了自己包里面的引擎，让外部可以方便的使用，比方说很多实现 database/sql 的引擎，在 init() 函数里面都是调用了 sql.Register(name string, driver driver.Driver) 注册自己，然后外部就可以使用了。

程序的初始化和执行都起始于 main 包，如果 main 包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被 导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。当一个包被导入时，如果该包还导入了其它的包，那么会先将其它 包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开始对 main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。下面是 init 的整个详细执行过程：

用在返回值 Copy Section

for _,v := range Slice{} // 表示丢弃索引值。

但是有些时候返回值不能丢弃，丢弃了会导致 memory leak，举个栗子：当你使用 http 请求第三方接口时，如果丢弃 response，那么 response 的 body 系统不会帮你 close，所以会导致很多的 time_wait，然后内存会缓慢上升。

_, err := func() // 单函数有多个返回值，用来获取某个特定的值，其他值不获取。

用在变量（接口实现检查） Copy Section

首先我们来看 gin 框架的源代码 ResponseWriter

type ResponseWriter interface {
	http.ResponseWriter
	http.Hijacker
	http.Flusher
	http.CloseNotifier

	// Returns the HTTP response status code of the current request.
	Status() int

	// Returns the number of bytes already written into the response http body.
	// See Written()
	Size() int

	// Writes the string into the response body.
	WriteString(string) (int, error)

	// Returns true if the response body was already written.
	Written() bool

	// Forces to write the http header (status code + headers).
	WriteHeaderNow()
}

type responseWriter struct {
	http.ResponseWriter
	size   int
	status int
}

var _ ResponseWriter = &responseWriter{}

其中 ResponseWriter 为 interface，用来判断 responseWriter 结构体是否实现了 ResponseWriter，用作类型断言，如果 responseWriter 没有实现接口 ResponseWriter，则编译错误。

更多源码，点击前往:gin/response_writer.go

延伸阅读 Copy Chapter

1. https://stackoverflow.com/questions/38548911/is-it-necessary-to-early-bounds-check-to-guarantee-safety-of-writes-in-golang
2. Bounds Checking Elimination
   • https://go.googlesource.com/go/+/master/test/prove.go
   • https://go.googlesource.com/go/+/master/test/loopbce.go
3. cmd/compile: unnecessary bounds checks are not removed #14808

Discuss 2018 05 09 Wechat Discuss (`content/discuss/2018-05-09-wechat-discuss.md`) Copy Section

title: 2018-05-09 微信群讨论 date: 2018-05-09T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：2018-05-09

1. debug Copy Chapter

调试：dlv

（待补充）

2. not reached Copy Chapter

go/src/runtime/panic.go

（待补充）

3. Go 开发工具 Copy Chapter

• Vim：（待补充）

• Emacs

• VSCode

• JetBrains: IntelliJ,Goland

  • Goland用学生邮箱可以免费
  • 服务器认证（这个就不贴了，大家自行Google）
  • 其他更多

• LiteIDE: LiteIDE的跟踪代码很不错,可以同时在一个窗口打开多个项目的目录.

4. 问题 Copy Chapter

var x string
func init() {
    x, err := getValue()
}

有一个全局变量 x，在 init() 函数里面赋值，然后获取 x 的值发现全局变量未赋值，这种情况有什么优雅的解决方法吗？

var x string
func init() {
    var err error
    x, err = getValue()
}

这个:=为什么不能对全局变量起作用呢？因为它成为局部变量了，屏蔽了全局变量作用域。

var x string 
func init()(err error) {
    x, err = getValue()
}

以上代码是 错误 的，Go 语言中 main() 和 init() 函数都不能有返回值，否则编译会报错：

func init must have no arguments and no return values
func main must have no arguments and no return values

参考资料 Copy Chapter

1. Go 开发工具

Discuss 2018 05 10 Which Vendor Tool (`content/discuss/2018-05-10-which-vendor-tool.md`) Copy Section

title: 2018-05-10 用什么工具解决项目依赖 date: 2018-05-10T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：2018-05-10 13:30

1. 你们是用什么工具解决项目依赖的呢？ Copy Chapter

• dep
• govendor

govendor 最简洁，glide最方便，不过一般团队用啥就用啥。

2. 平时你们的工作目录结果是怎样的？ Copy Chapter

• 一个大的 GOPATH 下，放所有项目【比较多是这种方式】

• 一个项目一个 GOPATH

• 有一个默认 GOPATH，不同项目有不同的 GOPATH

  VisualStudio Code 的设置： "go.gopath": "${workspaceRoot}:/Users/username/gopath"
  公共第三方包是公用的，每个有自己的 vendor，编译打包什么的都是各自的 makefile（很多Github上的大项目，比如docker，都是自己写 Makefile ，整理项目依赖，没有一个统一的形式）

Rust 的项目结构比 Go 好，Rust 的 cargo 还不错。

• 可以给 GOPATH 写一个脚本

gop() {
	if [ "$1" = "" ]; then
	elif [ "$1" = "d" ]; then
		export GOPATH=`echo $DEF_GOPATH`
	elif [ "$1" = "a" ]; then
		export GOPATH=`echo $DEF_GOPATH`:`pwd`
	elif [ "$1" = "f" ]; then
		export GOPATH=`pwd`
	fi

	echo "current GOPATH = "$GOPATH
}

参考资料 Copy Chapter

1. Go Vendoring Tools 使用总结
2. Golang 代码规范

Discuss 2018 05 13 Declaring Variables On If Else (`content/discuss/2018-05-13-declaring-variables-on-if-else.md`) Copy Section

title: 2018-05-13 关于变量在 if-else 条件表达式里的作用域范围 date: 2018-05-13T00:00:00+08:00 Copy Chapter

一. 如何发现这个问题? Copy Chapter

我是在浏览 Twitter 的时候, 发现博主 David Crawshaw 分享了一段代码,

推文地址:
https://twitter.com/davidcrawshaw/status/994614426064928770

原博文代码如下, 点击在 play 里运行:

package main

import "fmt"

func main() {
	if a := 1; false {

	} else if b := 2; false {

	} else if c := 3; false {

	} else {
		fmt.Println(a, b, c) // 结果: 1 2 3
	}
}

所以, 就扩展一下如下这种方式:

package main

import "fmt"

func main() {
	if a := 1; false {
		aa := 11
	} else if b := 2; false {
		bb := 22
	} else if c := 3; false {
		cc := 33
	} else {
		fmt.Println(a, b, c)
		fmt.Println(aa, bb, cc) // 结果: undefined aa bb cc
	}
}

再尝试如下这种方式:

package main

import "fmt"

func main() {
	if x := 10; x < 9 {
		fmt.Println(x)
	} else {
		fmt.Println("not x")
	}
	fmt.Println(x) // 结果: other if-else.go:11:14: undefined: x
}

脑洞再大点:

package main

import "fmt"

func main() {
	if a := 1; false {
		fmt.Println(a, b, c) // undefined: b, c
	} else if b := 2; false {
		fmt.Println(a, b, c) // undefined: c
	} else if c := 3; false {
		fmt.Println(a, b, c)
	} else {
		fmt.Println(a, b, c)
	}
}

合理的猜测:

package main

import "fmt"

func main() {
	if a := 1; false {

	} else if b := 2; false {

	} else if c := 3; false {

	} else {
		if a := 11; true {
			fmt.Println(a, b, c) // 11 2 3
		}
		fmt.Println(a, b, c) // 1 2 3
	}
}

所以可以得出一个初步的结论:

只有 if/else-if 条件表达式里的变量声明作用域才会向下到达最后 else 内部, 显而易见的不能向上作用, 作用域范围仅限于本级, 不影响正常的变量作用范围以及屏蔽作用.

二. 这么做有什么好处和坏处? Copy Chapter

A. 好处: Copy Section

1. 如下面 Chris Hines 评论列出的代码 , 在处理 sql 任务的时候, 对返回值和错误做处理, 逻辑上看, 比较流畅.

if result, err := db.Exec(updateSql, ...); err != nil {
	return err
} else if count, err := result.RowsAffected(); err != nil {
	return err
} else if count != 1 {
	return ErrNotUpdated
}

2. 另一个评论的代码,

emmmmm, 怎么说呢? 这么看代码确实比较简洁优美一些, 不过对于不了解这个特性的人来说, 可能有坑, 增加阅读难度.

if got, err := f(); err != nil {
	// 巴拉巴拉巴拉
} else if want := ...; got != want {
    t.Errorf(..., got, want)
}

好在我们可以加注释. 改成如下, 在可读性上会好点:

// NOTE: golang 特性, got 的作用域贯穿整个 if-else...
if got, err := f(); err != nil {
	// 巴拉巴拉巴拉
} else if want := ...; got != want {
    t.Errorf(..., got, want)
}

3. 语言的设计就是如此:

参考设计文档: https://golang.org/ref/spec#If_statements, 官方并没有明确的说这么做的好处. 不过确实给书写代码带来了方便.

B. 坏处: Copy Section

1. emmmmm, 就是对于不知道这个特性的人来说比较奇怪. 不是很理解, 不符合编程的核心原则: 代码首先是给人看的, 顺便给机器运行.

Discuss 2018 05 16 The Way To Go (`content/discuss/2018-05-16-the-way-to-go.md`) Copy Section

title: 2018-05-16 Go 学习之路 date: 2018-05-16T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：2018-05-16

推荐新手先看一看Go 学习之路

1. 有没有适合小白看的项目？（没有底层语言基础） Copy Chapter

• 建议先系统过一遍基础语法；
• 看了 Go 基础之后，可以把数据结构，排序:树、表等都撸一遍；
• 自己写点工具、爬虫之类的进步比较快；
• 推荐『Go 语言实战』，『Go 语言系列』，适合从入门到深入
• 编程书籍的整理和收集
• 雨痕大神些的『Go 语言学习笔记』也不错，包含语法介绍和源码剖析（可能不适合初学者哦，比较多的底层知识）

推荐项目

• beego
• BoltDB（不维护了，但是代码不多，注释比较详细，作为学习容易入门）
• urfave/cli
• grpc-gateway
• grpc-go

Discuss 2018 05 18 Bitset And Import Cycle Not Allowed (`content/discuss/2018-05-18-bitset-and-import-cycle-not-allowed.md`) Copy Section

title: 2018-05-18 包循环依赖如何解决 source: 『Go 夜读』微信群 date: 2018-05-18T00:00:00+08:00 Copy Chapter

1. 包循环依赖如何解决？ Copy Chapter

方法：

用 govendor list -v 可以查看一个包被哪些包依赖。

详解：

使用 govendor list -v 可以查看一个包被哪些包依赖：

那么反过来，你可能想知道一个包依赖了哪些包？这个是 go 工具链里面提供的方法，直接使用 go list，比如：go list -f '{{ .Imports }}' github.com/talkgo/night

2. bitset Copy Chapter

strings 包之 bitset，一个实现：https://github.com/henrylee2cn/goutil/blob/master/bitset/bitset.go

对于以上代码的一些讨论：

Q：1. 没有看到 unset，或者 clear 清除标志，2. 其次位的设置可以用 atomic 的 or 或操作，无锁编程效率更高。
A：可以加 clear，如果用原子锁就不能用 []byte 类型实现了。

Q：count 实现的太粗暴了，直接就一个一个的遍历，无法利用到 simd 和底层 cpu 指令。
A：count 字段可以用缓存字段，也就是可以用 map，也可以用 `math/bits` 这个库来实现。

Q：[]byte 为什么没办法使用原子锁，地址是有办法获得的。
A：那你知道锁的底层也是原子锁实现的吧？既然还是整个切片上锁，换成原子锁也一样的。

其实用库是最后的，这种实现不是最好的，往往 Go 的库能够实现 simd，在 go 1.x，编译期开始了对 simd 的支持。刚好算 byte 中置 1 的数目这个是可以很好的被 simd 的，这个叫 POPCNT ，机器指令，真正的 o(1)。

simd 是什么？ Copy Section

单指令流多数据流（英语：Single Instruction Multiple Data，缩写：SIMD）是一种采用一个控制器来控制多个处理器，同时对一组数据（又称“数据向量”）中的每一个分别执行相同的操作从而实现空间上的并行性的技术。

在微处理器中，单指令流多数据流技术则是一个控制器控制多个平行的处理微元，例如Intel的MMX或SSE，以及AMD的3D Now!指令集。

图形处理器（GPU）拥有强大的并行处理能力和可程式流水线，面对单指令流多数据流时，运算能力远超传统CPU。OpenCL和CUDA分別是目前最广泛使用的开源和专利通用图形处理器（GPGPU）预算语言。--摘自simd-维基百科。

Go 官方库的实现：

// math/bits/bits.go
// 位计数中的分治法
// OnesCount64 returns the number of one bits ("population count") in x.
func OnesCount64(x uint64) int {
	// Implementation: Parallel summing of adjacent bits.
	// See "Hacker's Delight", Chap. 5: Counting Bits.
	// The following pattern shows the general approach:
	//
	// 实现：相邻位的并行求和。
	// 见“黑客的喜悦”（见：算法心得：高效算法的奥秘（中文第2版）），章节.5：计数位。
	// 以下模式显示了一般方法：
	//   x = x>>1&(m0&m) + x&(m0&m)
	//   x = x>>2&(m1&m) + x&(m1&m)
	//   x = x>>4&(m2&m) + x&(m2&m)
	//   x = x>>8&(m3&m) + x&(m3&m)
	//   x = x>>16&(m4&m) + x&(m4&m)
	//   x = x>>32&(m5&m) + x&(m5&m)
	//   return int(x)
	//
	// Masking (& operations) can be left away when there's no
	// danger that a field's sum will carry over into the next
	// field: Since the result cannot be > 64, 8 bits is enough
	// and we can ignore the masks for the shifts by 8 and up.
	// Per "Hacker's Delight", the first line can be simplified
	// more, but it saves at best one instruction, so we leave
	// it alone for clarity.
	// 如果不存在字段总和将传送到下一个字段的危险，则可以将掩码（＆操作）留空：由于结果不能大于64，所以8位就足够了，我们可以忽略8位以上的移位掩码。 根据“Hacker's Delight”，第一行可以简化得更多，但它最多可以节省一条指令，所以为了清晰起见，我们只保留一条。
	const m = 1<<64 - 1
	x = x>>1&(m0&m) + x&(m0&m)
	x = x>>2&(m1&m) + x&(m1&m)
	x = (x>>4 + x) & (m2 & m)
	x += x >> 8
	x += x >> 16
	x += x >> 32
	return int(x) & (1<<7 - 1)
}

另外一个文档解释的非常清楚：Efficient_implementation

强烈推荐阅读(只能用于学习查阅，请勿分享传播，如有侵权，请联系我)：

• Hacker's Delit
• 算法心得：高效算法的奥秘（中文第2版）

其他 Copy Chapter

Wikiwand是一款能够改变维基百科条目界面的软件，2013年由利奥尔·格罗斯曼和依兰·列文创建，2014年8月正式上线。软件界面包含工具栏菜单、导航栏、其他语言版本的个性化链接、新版面和链接条目的预览。内容列表将在左侧不断显示。--摘自wikiwand 维基百科

参考资料 Copy Chapter

1. https://golang.org/pkg/math/bits/
2. https://golang.org/src/math/bits/bits.go
3. https://github.com/henrylee2cn/goutil#bitset
4. simd - 单指令流多数据流
5. https://www.wikiwand.com/en/Hamming_weight#/Efficient_implementation
6. https://zh.wikipedia.org/wiki/Wikiwand

Discuss 2018 05 21 Using Goroutines On Loop Iterator Variables (`content/discuss/2018-05-21-using-goroutines-on-loop-iterator-variables.md`) Copy Section

title: 2018-05-21 微信讨论 date: 2018-05-21T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-05-21

1. 如下代码何解？ Copy Chapter

a := []int{1,2,3}
for _, i:= range a {
	go func() {
		fmt.Println(i)
	}()
}
time.Sleep(time.Second)
// Output:
// 3
// 3
// 3

大家可以看参考资料 1, 2，上面有完整的解答。

延伸出来的知识点：惰性求值和闭包。

解答：
根据问题的描述推断出是闭包的特性，通过Google检索关键字 glang faq loop closure 可找到官方的faq，里面有详细的解释，并提醒了用户可以通过 go vet命令来检查程序中类似的问题。

最后官方的faq还给出了针对这个问题的两种解决方法。其中第一种方法很好理解，就是把变量v的值通过参数的形式传递给goroutine，因为go中func的参数传递都是值传递，所以就在goroutine启动时获得了当前v变量的值。

for _, v := range values {
    go func(u string) {
        fmt.Println(u)
        done <- true
    }(v)
}

第二种方法是更巧妙地通过一个赋值语句来解决的。

for _, v := range values {
    v := v // create a new 'v'.
    go func() {
        fmt.Println(v)
        done <- true
    }()
}

如果没有明白其中的原理，只要自己把赋值前后变量v的内存地址打印出来就明白了，在赋值后新的变量v实际上是在内存中开辟了一个新的空间并保存了当前变量v的值，两个变量并不是指向相同的内存地址。

for _, v := range values {
    fmt.Printf("Before assignment:%p\n", &v)
    v := v
    fmt.Printf("After assignment:%p\n", &v)
    go func() {
        fmt.Println(v)
        done <- true
    }()
}
// Output:
// Before assignment:0xc04206c080
// After assignment:0xc04206c090
// Before assignment:0xc04206c080
// After assignment:0xc04206c0a0
// Before assignment:0xc04206c080
// After assignment:0xc04206c0b0

2. []int 转 []int32 有没有什么好办法？ Copy Chapter

?

3. 大家的公司一般都用什么用于监控？ Copy Chapter

• zabbix
• grafana+influxdb
• openfalcon

参考资料 Copy Chapter

1. https://github.com/golang/go/wiki/CommonMistakes
2. https://golang.org/doc/faq#closures_and_goroutines

Discuss 2018 05 22 Go String To Byte Slice (`content/discuss/2018-05-22-go-string-to-byte-slice.md`) Copy Section

title: 2018-05-22 Go string to byte slice date: 2018-05-22T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-05-22

背景 Copy Chapter

去面试的时候遇到一道和 string 相关的题目，记录一下用到的知识点。题目如下：

s:="123"
ps:=&s
b:=[]byte(s)
pb:=&b

s+="4"
*ps+="5"
(*pb)[1] = 0
(*pb)[2] = 4

fmt.Printf("%+v\n",*ps)
fmt.Printf("%+v\n",*pb)

问以上代码的输出是什么。

分析 Copy Chapter

很容易可以看出 s 和 ps 代表同一个 string，b 和 pb 代表同一个 byte 的切片。关键在于

b:=[]byte(s)

根据 The Go Programming Language 的解释：

A string contains an array of bytes that, once created, is immutable. By contrast, the elements of a byte slice can be freely modified.
Strings can be converted to byte slices and back again:

s := “abc”
b := []byte(s)
s2 := string(b)

Conceptually, the []byte(s) conversion allocates a new byte array holding a copy of the bytes of s, and yields a slice that references the entirety of that array. An optimizing compiler may be able to avoid the allocation and copying in some cases, but in general copying is required to ensure that the bytes of s remain unchanged even if those of b are subsequently modified. The conversion from byte slice back to string with string(b) also makes a copy, to ensure immutability of the resulting string s2.

因为 string 是不可变的，所以不管是从 string 转到 []byte 还是从 []byte 转换到 string 都会发生一次复制。因此 p 和 b 可以看作两个内容相同的两个对象，对 p，b各自的修改不会影响对方。
先看 ps，经过两次拼接后就是 "12345"。
再看 pb，因为 s 中的内容都是 ASCII 字符，在 b 中只需要用一个 byte 就可以表示一个字符，所以 b 的实际内容是[49,50,51]，分别对应1，2，3的 ASCII 编码。经过就修改后就变成了[49,0,4]。

答案 Copy Chapter

经过上面的分析，最后输出的答案是"12345"和[49,0,4]

延伸 Copy Chapter

题目中对字符串的拼接也是常用的场景。因为 string 是不可变的，所以在拼接字符串时实际上也是将源字符串复制了一次，所以在 string 比较大时会消耗不少的内存和时间。关于字符串拼接的各种方法这里不详细展开了，有兴趣的可以参考以下几个链接：
https://gocn.io/question/265
https://gocn.io/article/704

Reference Copy Chapter

https://blog.golang.org/strings
https://sheepbao.github.io/post/golang_byte_slice_and_string/
http://nanxiao.me/golang-string-byte-slice-conversion/

Discuss 2018 05 23 Wechat Discuss (`content/discuss/2018-05-23-wechat-discuss.md`) Copy Section

title: 2018-05-23 Get passes lock by value date: 2018-05-23T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-05-23

1. Get passes lock by value Copy Chapter

type ExecuterList struct {
	sync.Map
	length int
}

func (e ExecuterList) Get(key string) IExecuter {
	value, ok := e.Load(key)
	if !ok {
		return nil
	}
	if value == nil {
		return nil
	}
	res, _ := value.(IExecuter)
	return res
}

使用 go tool vet ，出现“Get passes lock by value: ExecuterList contains sync.Map contains sync.Mutex”， 解决方案有两种：。

1，sync.Map用指针

type X struct {
	*sync.Map
}

2， 也可以用 (e *ExecutorList) ,避免锁的复制。

为什么会失效呢？

因为你每次操作都复制了一遍整个struct，当然也复制了Map里面的Mutex，多线程同时读写时Map里面的锁相当于失效了。理解这个你需要知道的知识点有两个，一是go的参数都是值传递，二是只有用同一把锁才能对某个资源边界进行锁与解锁的操作。

2. RPC 微服务框架 Copy Chapter

rpc 可以封装程序间网络通信层，服务间调用只需要关注目标服务是什么，不用关心我到底用什么协议和数据格式了。

为什么我推荐避免使用 go-kit 库？

Discuss 2018 05 28 Pprof In Go (`content/discuss/2018-05-28-pprof-in-go.md`) Copy Section

title: 2018-05-28 生产环境如何调试服务的内存泄露 date: 2018-05-28T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-05-28

1. 生产环境如何调试服务的内存泄露？ Copy Chapter

• pprof
• 火焰图

待补充...

如果用 gin 的话, 就一句代码.....https://github.com/DeanThompson/ginpprof

其他方法：目测法、删除法（删除怀疑的代码，然后压测）。

2. pprof 的数据如何实时采集到 influxdb ，有什么解决方案？ Copy Chapter

pprof 不能保存到 influxdb，想要保存的话，得使用 expvar 把 Golang 应用的内部数据传过去。

pprof 是一个运行时间段的数据，然后后续分析使用，线上应该使用 APM 方案。

appoptics-apm-go

pprof 算是监控的一种，promethues 中自带的 exporter 就有监控 go runtime 的数据，比如 goroutine 数量，栈等。

3. 返回的 int和interface的区别，如下图： Copy Chapter

dlv debug 一下，运行顺序是一样的，是不是 golang 的 bug 呢？
看汇编，不是完全看的懂，如果是interface的时候，会申请一个type为int空interface的结构，然后想把m的值复制给data区，但是结果就是没有成功。

参考资料 Copy Chapter

1. Go 自带 pprof
2. 容器环境下 go 服务性能诊断方案设计与实现
3. Golang 逃逸分析
4. spec: order of evaluation of variables in return statement is not determined
5. spec: Order_of_evaluation

Discuss 2018 06 07 Dial Timeout In Go (`content/discuss/2018-06-07-dial-timeout-in-go.md`) Copy Section

title: 2018-06-07 Dial 超时 date: 2018-06-07T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-06-07

问题1 Copy Chapter

func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error) {
func DialTimeout(network, address string, timeout time.Duration) (Conn, error) {

这两个方法返回的对象类型不一样，想得到TCPConn对象，同时可以设置连接超时，应该怎么写？有谁可以帮帮忙吗？

回答：

Use net.Dialer with either the Timeout or Deadline fields set.

d := net.Dialer{Timeout: timeout}
conn, err := d.Dial("tcp", addr)
if err != nil {
   // handle error
}

A variation is to call Dialer.DialContext with a deadline or timeout applied to the context.

Type assert to *net.TCPConn if you specifically need that type instead of a net.Conn:

tcpConn, ok := conn.(*net.TCPConn)

参考资料 Copy Chapter

1. https://stackoverflow.com/questions/47117850/how-to-set-timeout-while-doing-a-net-dialtcp-in-golang

Discuss 2018 07 02 C1000k On Linux (`content/discuss/2018-07-02-c1000k-on-linux.md`) Copy Section

title: 2018-07-02 在Linux操作系统环境，单机如何支撑100万并发的服务 date: 2018-07-02T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-02

问题1. 在Linux操作系统环境，单机如何支撑100万并发的服务 Copy Chapter

• 问题来源：

  HundredLee 在微信群里分享了一个掘金网的文章 GO千万级消息推送服务，然后另一个大佬 bye 说 goim 是哔哩哔哩在用的一个框架，可以支撑百万级并发连接，于是在“单机百万并发”这个问题上展开了热烈的讨论。

问题：我以前对并发的理解几乎都是错的，误以为每有一个客户端连接到服务器上就会多占用服务器的一个新TCP端口，但是看了文章和其他的QQ群的讨论，我终于搞明白了并发的概念。那么我的疑惑是单机如何才能支撑起100万的并发量呢？

答案 Copy Section

Linux服务器的并发连接数需要优化内核参数，在使用比较新的内核版本时，会有更好的优化效果。并发连接数主要和操作系统允许打开的文件描述符数量有关，需要设置 fs.file-max 和 fs.nr_open 参数，fs.file-max 参数设置的是整个操作系统允许创建的文件描述符数量的最大值，fs.nr_open 参数设置的是每个进程各自最多可以打开的文件描述符数量，这两个值限制 pam_limits.so 模块定义 的可打开文件描述符数量的参数上限。pam_limits.so 模块在定义了可打开的文件描述符数量的同时也就规定了 socket
的最大数量。所以服务能否支撑百万连接数首先取决于内核参数，然后取决于 pam_limits.so 模块的限制，pam_limits.so 模块决定了每个用户和组可用的资源。

另外还要对每一个TCP套接字连接占用的内存做分析，大概占4KByte；维护百万连接需要占用的内存就是 1000000 * 4KByte，大约是4GByte，还没有计算进去发送消息的开销，保守估算需要的内存是16GByte，如果要推送消息给这100万客户端，很显然非常吃力，反过来如果是100万的客户端排队发请求，就可以轮询处理队列里的请求了。

参考 Copy Chapter

• 大战C100K之4-Linux内核调优篇
• linux内核调优支持500K并发
• 通过ulimit和PAM来限制资源
• 关于 TCP 并发连接的几个思考题与试验
• Linux下Http高并发参数优化之TCP参数
• Linux TCP/IP 协议栈调优
• 单机千万并发连接实战
• 构建C1000K的服务器(1) – 基础
• 构建C1000K的服务器(2) – 实现百万连接的comet服务器
• Linux 中每个 TCP 连接最少占用多少内存？
• 关于pam_limits资源限制的回答
• Debian官方文档对于Limits的详细解释

Discuss 2018 07 04 Package Names (`content/discuss/2018-07-04-package-names.md`) Copy Section

title: 2018-07-04 文件夹命名 date: 2018-07-04T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-04

问题1. 话说大家 go 文件夹命名 是什么规范。下划线 横线 驼峰？有标准么？ Copy Chapter

有标准 https://blog.golang.org/package-names

问题2. 包的命名多个单词的情况呢？ Copy Chapter

包名和文件名用小写,使用短命名,尽量和标准库不要冲突。

文件名或者文件夹不要用大写，切记!!!

系统有些区别大小写，有些不区分，比如 Mac 不区分大小写，而 linux 区分。

制作规范的时候参考的是 effective go。

参考 Copy Chapter

• Golang 代码规范

Discuss 2018 07 09 Make New In Go (`content/discuss/2018-07-09-make-new-in-go.md`) Copy Section

title: 2018-07-09 怎么建立一个一一映射？ date: 2018-07-09T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-09

问题1. golang 怎么建立一个一一映射，现在的映射 map 是可以多对一的是吧？ Copy Chapter

建立两个 map 互查。

segment tree？

问题2. golang 中 new 和 make 关键字的区别和使用场景？ Copy Chapter

首先，我们看一下 Go 标准包的 builtin 源码吧（go/src/builtin/builtin.go）

// The make built-in function allocates and initializes an object of type
// slice, map, or chan (only). Like new, the first argument is a type, not a
// value. Unlike new, make's return type is the same as the type of its
// argument, not a pointer to it. The specification of the result depends on
// the type:
//	Slice: The size specifies the length. The capacity of the slice is
//	equal to its length. A second integer argument may be provided to
//	specify a different capacity; it must be no smaller than the
//	length. For example, make([]int, 0, 10) allocates an underlying array
//	of size 10 and returns a slice of length 0 and capacity 10 that is
//	backed by this underlying array.
//	Map: An empty map is allocated with enough space to hold the
//	specified number of elements. The size may be omitted, in which case
//	a small starting size is allocated.
//	Channel: The channel's buffer is initialized with the specified
//	buffer capacity. If zero, or the size is omitted, the channel is
//	unbuffered.
func make(t Type, size ...IntegerType) Type

// The new built-in function allocates memory. The first argument is a type,
// not a value, and the value returned is a pointer to a newly
// allocated zero value of that type.
func new(Type) *Type

new 它接受一个参数，这个参数是一个类型，不是一个值，分配好内存后，返回一个指向该类型内存地址的指针，同时请注意它同时把分配的内存置为零，也就是类型的零值。

new 不常用：new 在一些需要实例化接口的地方用的比较多，但是可以用 &A{} 替代。

但是 new 和 &A{} 也是有差别的，主要差别在于 &A{} 显示执行堆分配。

make 也是用于内存分配的，但是和new不同，它只用于channel,map 以及 slice 的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。

注意：这三种类型是引用类型，所以必须得初始化，但是不是置为零值，这个跟new是不一样的。

举例说明：

package main

import "fmt"

func main() {
    p := new([]int) //p == nil; with len and cap 0
    fmt.Println(p)

    v := make([]int, 10, 50) // v is initialed with len 10, cap 50
    fmt.Println(v)

    /*********Output****************
        &[]
        [0 0 0 0 0 0 0 0 0 0]
    *********************************/

    (*p)[0] = 18        // panic: runtime error: index out of range
                        // because p is a nil pointer, with len and cap 0
    v[1] = 18           // ok
    
}

// 作者：iCaptain
// 链接：https://www.jianshu.com/p/c173dab0e71c
// 來源：简书
// 简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

go 的逃逸分析决定了是分配到堆上还是栈上。

参考 Copy Chapter

• Effective Go#allocation_new
• Effective Go#allocation_make
• Go 语言机制之逃逸分析（Language Mechanics On Escape Analysis）
• Go 的变量到底在堆还是栈中分配
• Golang 变量逃逸分析小探

Discuss 2018 07 11 Using 64bit Atomic In 32bit System (`content/discuss/2018-07-11-using_64bit_atomic_in_32bit_system.md`) Copy Section

title: 2018-07-11 在32位系统中使用64位原子操作的坑 date: 2018-07-11T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-11

在32位系统中使用64位原子操作的坑 Copy Chapter

先来个例子 Copy Section

type Y struct {
	a bool
	v uint64
}

func TestAtomicY(t *testing.T) {
	var y Y
	atomic.AddUint64(&y.v, 1) // panic in 32bit system
}

在上面的例子中，如果在64位系统中运行是没问题的的，但是在32位系统中会panic。

为何会 Panic ？ Copy Section

这个简单回答可以查看，go官方的文档atomic-pkt-note的内容：

Bugs

On x86-32, the 64-bit functions use instructions unavailable before the Pentium MMX.

On non-Linux ARM, the 64-bit functions use instructions unavailable before the ARMv6k core.

On both ARM and x86-32, it is the caller's responsibility to arrange for 64-bit alignment of 64-bit words accessed atomically. The first word in a variable or in an allocated struct, array, or slice can be relied upon to be 64-bit aligned.

意思就是你如果要在32位系统中用64位的原子操作，必须要自己保证64位对齐，也就是8字节对齐。
如果要看汇编怎么判断的可以查看atomic·Xadd64

如果需要在一个struct中维护多个64位字段，且都需要原子操作，怎么办？ Copy Section

最简单的办法就是将所有64位字段放在struct的头部，这样就可以保证8字节对齐，如果你把这个struct嵌入在别的结构体，也要记得嵌入到头部。

一些例子 Copy Section

package aotmic_test

import (
	"log"
	"sync/atomic"
	"testing"
	"unsafe"
)

type X struct {
	v uint64
	x uint64
	a bool
	z uint64
	y uint32
}

func TestAtomic(t *testing.T) {
	var x X
	log.Printf("x.a=%p, offset=%d, alig=%d", &x.a, unsafe.Offsetof(x.a), unsafe.Alignof(x.a))
	log.Printf("x.v=%p, offset=%d, alig=%d", &x.v, unsafe.Offsetof(x.v), unsafe.Alignof(x.v))
	log.Printf("x.x=%p, offset=%d, alig=%d", &x.x, unsafe.Offsetof(x.x), unsafe.Alignof(x.x))
	log.Printf("x.y=%p, offset=%d, alig=%d", &x.y, unsafe.Offsetof(x.y), unsafe.Alignof(x.y))
	log.Printf("x.z=%p, offset=%d, alig=%d", &x.z, unsafe.Offsetof(x.z), unsafe.Alignof(x.z))
	log.Printf("x.v=%p", &x.v)
	atomic.AddUint64(&x.z, 1) // panic
}

type Y struct {
	a bool
	X
}

func TestAtomicY(t *testing.T) {
	var y Y
	x := y.X
	atomic.AddUint64(&x.v, 1)
	atomic.AddUint64(&y.X.v, 1) // panic
}

type Y2 struct {
	X
	a bool
}

func TestAtomicY2(t *testing.T) {
	y := &Y2{}
	atomic.AddUint64(&y.X.v, 1)
}

type Temp struct {
	A byte
	B [2]byte
	C int64
}

func TestAtomicTemp(t *testing.T) {
	var x Temp
	log.Printf("sizof=%d", unsafe.Sizeof(x))
	log.Printf("x.A=%p, offset=%d, alig=%d", &x.A, unsafe.Offsetof(x.A), unsafe.Alignof(x.A))
	log.Printf("x.B=%p, offset=%d, alig=%d", &x.B, unsafe.Offsetof(x.B), unsafe.Alignof(x.B))
	log.Printf("x.C=%p, offset=%d, alig=%d", &x.C, unsafe.Offsetof(x.C), unsafe.Alignof(x.C))
}

参考链接 Copy Section

 https://go101.org/article/memory-layout.html

https://github.com/golang/go/issues/5278

Discuss 2018 07 14 Version Gopath Go Command (`content/discuss/2018-07-14-version-gopath-go-command.md`) Copy Section

title: 2018-07-14 包版本管理 date: 2018-07-14T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-14

问题1：包版本管理？ Copy Chapter

govendor,vgo?

vgo 是 Go Module 的前身。

问题2：为什么要搞一个 GOPATH ？ Copy Chapter

GOPATH 是 Go 最初设计的产物，在 Go 语言快速发展的今天，人们日益发现 GOPATH 似乎不那么重要了，尤其是在引入 vendor 以及诸多包管理工具后。并且 GOPATH 的设置还会让 Go 语言新手感到些许困惑，提高了入门的门槛。Go core team 也一直在寻求 “去 GOPATH” 的方案，当然这一过程是循序渐进的。Go 1.8 版本中，如果开发者没有显式设置 GOPATH，Go 会赋予 GOPATH 一个默认值（在 linux 上为 $HOME/go ）。虽说不用再设置 GOPATH，但 GOPATH 还是事实存在的，它在 go toolchain 中依旧发挥着至关重要的作用。

问题3：go get 命令内部应该也是用 git clone 命令吧？ Copy Chapter

https://github.com/golang/go/wiki/GoGetTools
https://github.com/hyper0x/go_command_tutorial/blob/master/0.3.md

参考链接 Copy Section

1. https://github.com/golang/go/wiki/PackageManagementTools
2. 初窥 Go Module
3. https://git-scm.com/docs/revisions
4. https://dave.cheney.net/2018/07/14/taking-go-modules-for-a-spin

Discuss 2018 07 31 Println Println And Context (`content/discuss/2018-07-31-println-Println-and_context.md`) Copy Section

title: 2018-07-31 println 与 fmt.Println 有何猫腻 date: 2018-07-31T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-07-31

问题1：println与fmt.Println有何猫腻？ Copy Chapter

下面2个输出语句代码，哪一行先输出

package main

import "fmt"

func main() {
	println("11111")
	fmt.Println("22222")
}

本人的是debian linux系统下，go version为1.9.1，goland IDE,反复执行几次之后发现始终"反着"输出

22222
11111

按照一般人的思维惯性(或者说下意识)，应该先输出11111，再输出22222,然后向Go夜读微信群发起提问，结果群友测试的结果就是顺序输出，他的测试环境是macbook, go version1.10.3

package main

import "fmt"

func main() {
	println("aaaaa")
	fmt.Println("bbbbb")
}

输入

aaaaa
bbbbb

难道是因为内容不同就不一样？难道是因为和系统有关？难道是和go版本有关？

我们看下println源代码，如下：

// 大概意思是：println内置函数将其参数格式化为特定实现方式，然后将结果写入标准错误流
// 而Println函数对于我们开发程序的时候调试输出很有用,且不能保证以后会留在语言中

// The println built-in function formats its arguments in an
// implementation-specific way and writes the result to standard error.
// Spaces are always added between arguments and a newline is appended.
// Println is useful for bootstrapping and debugging; it is not guaranteed
// to stay in the language.
func println(args ...Type)

我们再看看Println源代码,如下：

// 大概意思是：Println函数使用默认格式化并将结果写入标准输出流
// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Println(a ...interface{}) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}

看了2个函数的实现之后，总结如下：

1. println是输出到stderr
2. fmt.Println是输出到stdout

fmt.Println writes go standard output(stdout) and println writes to standard error (stderr),two different,unsynchronized files

结论：linux中，标准输入，标准输出，标准错误分别对应三个管道，编号分别是0,1,2，不同的管道输出是并发，不存在不同的管道之间相互等待，也就不存在先后顺序，上面两个函数是输出到不同的输出管道，就有可能导致顺序不一致，一个终端总是会存在标准输出和标准错误输出。所以最开始的那个问题是随机输出，没有固定的顺序!,写个大点的循环就能容易发现是随机，不存在系统不一致，或者go版本不一致导致顺序可能不同。

问题2：context.Context普通用，是不是主要通过with value？ Copy Chapter

问题： context.Context普通用，是不是主要通过with value,可以传递部分参数而不用传递全部参数，然后调用的函数可以把对应的参数取出来？对这个问题，各位有什么看法？
答：参考链接：http://www.flysnow.org/2017/05/12/go-in-action-go-context.html

Discuss 2018 08 02 Apns Push Notification (`content/discuss/2018-08-02-apns-push-notification.md`) Copy Section

title: 2018-08-02 Push Notification (apns) date: 2018-08-02T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：2018-08-02

问题: 如何批量发送apns消息推送 Copy Chapter

Install apns2

go get -u github.com/sideshow/apns2

先看下如何发送一条的apns.

func push(){
    cert, err := certificate.FromP12File("../cert.p12", "")
    if err != nil {
        log.Fatal("Cert Error:", err)
    }

    notification := &apns2.Notification{}
    notification.DeviceToken = "11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7"
    notification.Topic = "com.sideshow.Apns2"
    notification.Payload = []byte(`{"aps":{"alert":"Hello!"}}`) // See Payload section below

    client := apns2.NewClient(cert).Production()
    res, err := client.Push(notification)

    if err != nil {
        log.Fatal("Error:", err)
    }
    fmt.Printf("%v %v %v\n", res.StatusCode, res.ApnsID, res.Reason)
}

一开始会想到,当需要推送大量消息的时候,会想到每发一条推送的时候,开一个协程(当然也要限制协程的数量),像这样:

go push()

但是一个问题,apns我记得是最多只能挂载15个tls.也就是最多同时发送15条推送消息,远远不能满足像IM需要大量同时推送的需求.

tls

而tls是14年的时候,苹果官方发布更换了所有的通讯协议:

"鉴于SSL 3.0最新发现的漏洞，为了保护用户，APNS决定在下周三也就是10月29号起开始停止对SSL 3.0的支持。所有仅支持SSL 3.0的推送服务需要更换为TLS以确保推送服务能够正常运行，同时支持了SSL 3.0和TLS的服务不会受到此次更新的影响。"

使用tls解决了http1的两个问题:

1.安全性无法保证
2.单次请求获取一个文档的方式，不满足如今流式传输体验所要求的性能

所以http2中的tls具有流式传输功能的,相比http1.他可以首次建立连接请求,响应返回之后并不会断开连接.他不用向HTTP1那样,每次发送请求都需要建立一次.更重要的是他一次建立连接后,通过这个连接的所有请求都不用等待上一次请求的响应返回,而是可以同时发送请求.

解决批量的方案是:

服务端接收到发送推送消息的请求后,不是马上发送,而是等待100ms,收集所有这段时间的所有推送请求(设置一个上限),一次向一个tls中去推送.

先看下我们的推送架构,基本是根据现有的架构自我调整:

| 消息队列 |
↓
| 消息收集器 |
↓
| 消息合并 |
↓
| 过 滤 器 |
↓
推送模块

1.最上层就不多加说明了,根据自己公司的消息队列获取到要推送的消息.

2.消息收集器是一次获取批量的推送消息,基本公司使用像成熟的消息队列也可以不需要这一层,如果类似使用的redis队列,一次只能获取一个推送消息,就需要加这一层,获取一段时间或者一定量的推送消息,再推给下一层.

for   {
  //检验是否跳出循环,将数据给到下层
  nowTime := time.Now().UnixNano()
  if nowTime - beginTime > 150 * millisecond {
      if len(p_items) != 0 || len(g_items) != 0 || len(c_items) != 0 || len(s_items) != 0  {
          break
      }
      beginTime = time.Now().UnixNano()
  }else if len(p_items) >= 100 {
      break
  }else if len(g_items) >= 500 {
      break
  }else if len(c_items) >= 100 {
      break
  }else if len(s_items) >= 100 {
      break
  }
  
  /*从队列获取推送消息*/
  
 }
 //推给下一层消息收集器
 if len(p_items) != 0 {
 p_chan<-p_items
 }
 
 if len(g_items) != 0 {
 g_chan<-g_items
 }
 
 if len(c_items) != 0 {
 c_chan<-c_items
 }
 
 if len(s_items) != 0 {
 s_chan<-s_items
 }

3.消息合并是用来合并群消息,系统消息.适用于同样的内容,推给不同的对象.

for msgs := range g_chan {   //这里要小心,不要用到了defer,不然会一直都不释放.
    
    // 合并相同的群消息
    var msgs_dict = make(map[string]*group_msg)
    /*略*/
    for _, gmsg := range group_msgs {
    
        obj, ok := msgs_dict[gmsg.uuid]
        if ok {
        receivers := obj.receivers
        for i := 0; i < len(gmsg.receivers); i++ {
            //合并
            receivers = append(receivers, gmsg.receivers[i])
        }
        //保存在map
        obj.receivers = receivers
        msgs_dict[gmsg.uuid] = obj
    
        } else {
        msgs_dict[gmsg.uuid] = gmsg
        }
    }
    /*略*/
}

4.过滤器是过滤一些敏感的词语,过滤一些特殊的消息体.

5.推送模块,我们要讲的就是apns2.

获取certificate文件:

func get_apns_cert(P12 string,P12_SECRET string) *tls.Certificate {
  cert, err := certificate.FromP12File(P12, P12_SECRET)
  if err != nil {
      log.Fatal("Cert Error:", err)
      return nil
  }
  return &cert
}

获取apns:

func (ap *Apns_push)get_apns_client(appid int64,P12 string,P12_SECRET string) *apns2.Client {

  if cer,ok := ap.Apns_cert_dict[appid];ok {
      client := ap.Client_manager.Get(cer) //Client_manager -> *apns2.ClientManager
      return client
  }
  cert := get_apns_cert(P12 ,P12_SECRET)
  if cert == nil {
      return nil
  }
  ap.Lock()
  ap.Apns_cert_dict[appid] = *cert
  ap.Unlock()
  client := apns2.NewClient(*cert)
  ap.Client_manager.Add(client) //Client_manager -> *apns2.ClientManager
  return client
}

编辑apns消息体:

func(ap *Apns_push)Apns_push(ams []*APNs_msg)  {
  var notifications []*apns2.Notification
  for _,am := range ams {

      p := payload.NewPayload()
      p.Badge(am.Badge)
      p.Alert(am.Content)
      if am.Sound == "" {
          am.Sound = "default"
      }
      p.ThreadID(am.Uuid)
      p.Sound(am.Sound)
      if am.Custom !=nil {
          for k,v := range am.Custom {
              p.Custom(k,v)
          }
      }

      notification := &apns2.Notification{
          DeviceToken:am.DeviceToken,
          Topic:am.Bundle_id,
          Payload:p,
      }
      notifications = append(notifications, notification)
  }
  ap.NotificationsCh<-notifications
}

推送:

func send(client *apns2.Client,notification *apns2.Notification,isRepeat bool,seq int64)  {
    res, err := client.Development().Push(notification)
    if err != nil {
        log.Warnf("Push fail seq:%d -- %v %v %v   token:%s \n",seq, res.StatusCode, res.ApnsID, res.Reason ,notification.DeviceToken)
        if isRepeat {
            seq++
            send(client,notification,false,seq)
        }
        return
    }
    log.Infof("Push success seq:%d -- %v %v %v   token:%s \n",seq, res.StatusCode, res.ApnsID, res.Reason ,notification.DeviceToken)
}

参考资料 Copy Chapter

go-apns2

网络协议之TLS

Discuss 2018 08 02 Go Shell (`content/discuss/2018-08-02-go-shell.md`) Copy Section

title: 2018-08-02 Go 调用 shell 脚本如何传递参数 date: 2018-08-02T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：2018-08-02

问题：Go 调用 shell 脚本如何传递参数？ Copy Section

答：

package main

import (
    "fmt"
    "os/exec"
)

func main(){
    command := "./dir_size.sh" //脚本的路径
    cmd := exec.Command("/bin/bash", "-c", command)

    output, err := cmd.Output()
    if err != nil {
	fmt.Printf("Execute Shell:%s failed with error:%s", command, err.Error())
	return
    }
    fmt.Printf("Execute Shell:%s finished with output:\n%s", command, string(output))
}

其中 Command 源代码是：

func Command(name string, arg ...string) *Cmd {
	cmd := &Cmd{
		Path: name,
		Args: append([]string{name}, arg...),
	}
	if filepath.Base(name) == name {
		if lp, err := LookPath(name); err != nil {
			cmd.lookPathErr = err
		} else {
			cmd.Path = lp
		}
	}
	return cmd
}

其中 name 是执行的命令，args是参数，所以传递参数可以直接写 cmd := exec.Command("/bin/bash", "-c", "参数1","参数","参数") 这样就可以，arg... 为可变参数。

要理解为什么要这么传参，就要理解 bash -c 的用法

bash -c 传参的方法：
用法: bash -c "cmd string"
通常使用 shell 去运行脚本，两种方法 bash xxx.sh，另外一种就是 bash -c "cmd string" 。
对于 bash xxx.sh，首先 bash 会在当前目录去寻找 xxx.sh ，如果找到，就直接运行，找不到则按照环境变量 $PATH 的指定路径，按顺序去找，如果找到，则执行，找不到则报错。
shell 脚本的参数 $0 就是要执行的 shell 脚本 xxx.sh， $1 就是后面紧跟 xxx.sh 的参数，$2 $3依次类推。

而对于 bash -c "cmd string"

-c If the -c option is present, then commands are read from the first non-option argument command_string. If there are arguments after the command_string, they are assigned to the positional parameters, starting with $0.

大致意思就是，如果用 -c 那么 bash 会从第一个非选项参数后面的字符串中读取命令，如果字符串有多个空格，第一个空格前面的字符串是要执行的命令，也就是 $0，后面的是参数，即 $1, $2...

参考 Copy Chapter

1. bash -c 注意事项

Discuss 2018 08 09 Log Color In Go (`content/discuss/2018-08-09-log-color-in-go.md`) Copy Section

title: 2018-08-09 Log 的颜色能设置吗 date: 2018-08-09T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-09

问题：Log 的颜色能设置吗？ Copy Section

答：可以的。

func TestLogColor(t *testing.T) {
	fmt.Println("")

	// | 前景 | 背景 | 颜色 |
	// |----|----|----|
	// | 30 | 40 | 黑色 |
	// | 31 | 41 | 红色 |
	// | 33 | 42 | 绿色 |
	// | 33 | 43 | 黄色 |
	// | 34 | 44 | 蓝色 |
	// | 35 | 45 | 紫红色 |
	// | 36 | 46 | 青蓝色 |
	// | 37 | 47 | 白色 |
	//
	// | 代码 | 意义 |
	// |----|----|
	// | 0 | 终端默认设置 |
	// | 1 | 高亮显示 |
	// | 4 | 使用下划线 |
	// | 5 | 闪烁 |
	// | 7 | 反白显示 |
	// | 8 | 不可见 |

	for b:= 40; b<=47; b++ {
		for f:= 30; f <= 37; f++ {
			for d:= range []int{0, 1, 4, 5, 7, 8} {
				fmt.Printf(" %c[%d;%d;%dm%s(f=%d,b=%d,d=%d)%c[0m ", 0x1B, d, b, f, "", f, b, d, 0x1B)
			}
			fmt.Println("")
		}
		fmt.Println("")
	}

	fmt.Printf("%c[1;40;32m%s%c[0m", 0x1B, "testPrintColor", 0x1B)
	fmt.Println()
	fmt.Printf("%s\n", "testPrintColor")
}

$ go test -v log_color_test.go

对于以上代码的解释：

在其中 \x1b[ 实现 CSI：
转换前景色为黑色，使用 \x1b[30m
转换为红色，使用 \x1b[31m
如果使用加粗参数，灰色写作 \x1b[30;1m
获取红色加粗，使用 \x1b[31;1m
重置颜色为缺省值，使用 \x1b[39;49m （或者使用 \x1b[0m 重置所有属性）

\033[0m 重置为正常 
\033[1m 设置高亮度或加粗 
\033[4m 下划线 
\033[5m 闪烁 
\033[7m 反显 
\033[8m 消隐 
\033[30m -- /33[37m 设置前景色 
\033[40m -- /33[47m 设置背景色

控制符 ESC 的常用表示方法 \e、\x1b(\x1B)、\033 都可以 \e 指代 Escape，对应八进制 \033，对应十六进制 \x1b。

摘自于教你写一个color日志库，不止有代码还有原理。

参考 Copy Chapter

1. https://en.wikipedia.org/wiki/ANSI_escape_code
2. https://github.com/fatih/color

Discuss 2018 08 14 Wechat Discuss (`content/discuss/2018-08-14-wechat-discuss.md`) Copy Section

title: 2018-08-14 做实时语音流，用什么来做比较好 date: 2018-08-14T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-14

问题：做实时语音流，用什么来做比较好？rtmp？还是ws？ Copy Section

• 第三方：即构（推荐）、声网（自己做不稳定，还得搞流媒体服务器）
• 自己做一般都是rtmp

实时？需要有多实时？直播还是点到点通信？
A：有一个实现是在 boya 的 rtmp 协议基础上，完善了 golang 的 rtmp 流媒体服务器，最近已经上网运行了，支持查询回源，定点回源等，资源消耗很低。也可参考项目livego

Go 默认使用 CPU 核数？ Copy Section

具体代码：proc.go#schedinit()。

文档说明：runtime-GOMAXPROCS

Another potentially breaking change is that the runtime now sets the default number of threads to run simultaneously, defined by GOMAXPROCS, to the number of cores available on the CPU. In prior releases the default was 1. Programs that do not expect to run with multiple cores may break inadvertently. They can be updated by removing the restriction or by setting GOMAXPROCS explicitly. For a more detailed discussion of this change, see the design document - Russ Cox.

discuss on golang-dev

etcd Copy Section

etcd 心跳超时是 1s ；
etcd 用了raft 分布式一致性算法。
其他的内容有待后续整理。。。

参考 Copy Chapter

1. Raft一致性算法论文
2. 分布式一致性算法：可能比你想象得更复杂

Discuss 2018 08 15 Wechat Discuss (`content/discuss/2018-08-15-wechat-discuss.md`) Copy Section

title: 2018-08-15 深度 | 从 Go 高性能日志库 zap 看如何实现高性能 Go 组件 date: 2018-08-15T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-15

深度 | 从 Go 高性能日志库 zap 看如何实现高性能 Go 组件 Copy Section

一篇技术文章引发的讨论。

• 我们有一个服务用 logrus 落日志，并发量太高了，直接影响了性能。

• printf 类型字符串格式化的日志格式，不再推荐，现在日志的消费，逐渐从人转向了计算机，结构化的数据和友好的解析方式更重要。---跟 logrus 的作者观点一样，“核心不是性能”。。。

• 我们后面也用 sync.Pool 去优化落日志这一块。（当时因为 logrus 写日志这一块，直接在高并发的时候多开销了10G内存，当时服务总共开销才 15 G内存。后面做了一些优化，用 sync.Pool 提前把日志格式化好，不是用 logrus 里面的 WithFields 之类的，后来对比过 zerolog，但是优化后在 3W 左右的日志并发时，从我们服务器的监控来看，整体没有太大的区别（内存、CPU、服务器的整体速度），所以后面也没有更换 log 库。（原因是在于替换成本也比较高。））

Echo 里面的 context 也是用 sync.Pool 解决高并发的时候内存占用问题 Copy Section

sync.Pool 的定位不是做类似于连接池的东西，它的用途仅仅是增加对象重用的几率，减少 gc 的负担，而开销方面也不是很便宜的。

sync.Pool 本来就是当做 cache 用的，在 Go 官方文档上已经明确说明了，数据不能保存在 pool 里面，有可能会遇到 GC 回收。

A Pool is a set of temporary objects that may be individually saved and retrieved.

Any item stored in the Pool may be removed automatically at any time without notification. If the Pool holds the only reference when this happens, the item might be deallocated.

参考 Copy Chapter

1. 深度 | 从 Go 高性能日志库 zap 看如何实现高性能 Go 组件
2. kingsoft-wps-log4go
3. go语言的官方包sync.Pool的实现原理和适用场景
4. 大幅提升 golang 写日志序列化性能实践

Discuss 2018 08 23 Wechat Discuss (`content/discuss/2018-08-23-wechat-discuss.md`) Copy Section

title: 2018-08-23 有什么好的博客平台吗 date: 2018-08-23T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-23

有什么好的博客平台吗？（除了简书） Copy Section

• Github pages
• hugo + Github
• 自建
• jekyll
• Ghost
• hexo + Github
• hexo + Coding pages

图片CDN：七牛

请问nats有类似[kafka manager](https://github.com/yahoo/kafka-manager)这样的管理后台吗？ Copy Section

• kafka manager 的管理后台：kafkatool

对kafka的抽象 Copy Section

kafka聚焦于数据管道，nats聚焦于message bus

for-select ? Copy Section

下面这段代码为什么运行一会儿就停止了呢?

用 waitgroup 肯定是正常的，研究一个 go sceduler 的问题，所以才故意这样写的。

for {}这种死循环（现实中应该用不着，反正我没用过这种需求），编译的时候不会被go插入抢占的代码（morestack 函数），导致调度切换不出去。这个问题go团队已经在着手解决了 golang/go/issues#24543，不理解的话，可以看看:

加打印会有系统调用，就会插入调度抢占代码，抢占调度的前提是需要插入morestackt代码，和编译器和调度机制都有关系。。

go 中加入 spinning threads 的目的是啥，有相关资料吗？

让 M 工作。

spin 和 unspin 对应就是 M 运行和休眠的状态，也就是线程运行和休眠的状态，M 只有实在找不多 G 来做的时候才会休眠。

参考 Copy Chapter

1. 系统设计入门
2. https://stackshare.io/stackups/kafka-vs-nsq-vs-rabbitmq
3. https://github.com/golang/go/issues/15442
4. https://rakyll.org/scheduler/

Discuss 2018 08 24 Wechat Discuss (`content/discuss/2018-08-24-wechat-discuss.md`) Copy Section

title: 2018-08-24 工具推荐 date: 2018-08-24T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-24

工具推荐 Copy Section

1. SequelPro(MySQL Client GUI)
2. Robot 3T(MongoDB Client GUI)
3. mycli(MySQL command line client)
4. Navicat Premium(DB Client GUI)
5. DataGrip: Database management systems by JetBrains
6. SQLyog is an all-round Management Tool (/'GUI'/'Frontend') for MySQL

Discuss 2018 08 30 Understanding Go Interfaces (`content/discuss/2018-08-30-understanding-go-interfaces.md`) Copy Section

title: 2018-08-30 理解 Go interface date: 2018-08-30T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-08-30

Go 语言不同接口、声明了同名方法，怎么解决问题？ Copy Section

1. 防止被其他对象误实现接口。

由此，我陷入了一些思考，所以也引申出来了对 Go 接口实现或者是否这个是一个推荐的做法呢？

网络上的一些讨论[为什么我不喜欢Go语言式的接口（即Structural Typing）](http://blog.zhaojie.me/2013/04/why-i-dont-like-go-style-interface-or-structural-typing.html) Copy Section

Structural_type_system 是什么？摘自于 wiki

Duck_typing

一些讨论。。。 Copy Section

Wuvist 对 Go 语言接口的个人观点

Go里面类适用于哪些接口，不也是程序员显示指定的吗？

区别在于是实现者显示指定，还是调用者显示指定。

我也可以说作为调用者，你非要乱使用一个你不了解的类，那也没人可以拦着你。

但抬杠毫无意义。

值得讨论的，是接口调用者还是接口实现者责任的问题；这才是“Go语言式接口”与常见语言接口的本质不同。

科技球对 Go 语言接口的个人观点

我对“自由严格”之争的基本观点：

第一，我不认为用interface去检查一切能够检查的东西，换句话说，用interface去表达一切library实现者对使用者的约定就是最好的design。我们需要分清楚什么东西是适合用程序语言表达的，什么东西是适合用自然语言表达的，甚至什么东西是适合用数学语言表达的（O(1), O(n)什么的不正是数学语言吗？）。程序语言不适合表达所有的东西，不然我们干嘛需要看编程书，算法书呢？

第二，什么东西适合用程序语言去表达？我觉得程序语言归根结底是人与机器交流的平台，而不是人与人交流的平台。我们之所以提倡静态语言，是为了给计算机表达出足够的信息让计算机能够根据这些信息进行优化，同时利用计算机在编译的时候做一些类似于拼写检查的东西避免人类常犯的错误。但程序不适合用来做人与人交流的平台，哪怕是程序员与程序员交流的平台，与其设计一种语言去表达什么O(1),O(n)，thread-safety之类的信息，何不更简单地在注释或者文档里写清楚？同理，技术上的检验也不是越多越好，拼写错误这些是人类常犯的错误，但是high-level的概念上的错误，比如送画画的小明去决斗却是程序员本身就不应该犯的错误。用interface这种程序语言去表达编程的思想，最终的结果就是编程的思想禁锢在程序语言设计者制定的牢笼里。

...

参考资料 Copy Chapter

1. A Tour of the Go Programming Language with Russ Cox
2. 深入理解 interface
3. Understanding Go Interfaces - YouTube
4. Understanding Go Interfaces - Slide
5. Go语言中隐式接口的冲突问题
6. 《Go语言高级编程》- 接口
7. 理解 Go interface 的 5 个关键点

Discuss 2018 09 04 Wechat Discuss (`content/discuss/2018-09-04-wechat-discuss.md`) Copy Section

title: 2018-09-04 微信讨论 date: 2018-09-04T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

Request Body 的请求中，不能 bind 两次吗？ Copy Section

var body struct {
	Fcid string "fcid"
}
c.Bind(&body)
log.Traceln("body", body)
var body2 struct {
	Fcid string "fcid"
}
c.Bind(&body2)
log.Traceln("body2", body2)

打印输出结果为：

2018/09/04 14:58:44.641654 [TRC] jwtValidator.go:34: body {@sign-test2}
2018/09/04 14:58:44.641674 [TRC] jwtValidator.go:41: body2:  {}

Body 不是 is.Seeker 无法 seek，应该不能重复 bind 的。

protobuf 3 枚举第一个必须是0，但是用的时候，用第一个 struct 会是空 Copy Section

log.Println(protocol.RESULT_CODE)
xxx := &protocol.XResp{
	Result: protocol.RESULT_CODE,
}
log.Println(xxx)

// OUTPUT:
// 2018-09-06 09:06:00.111 [d] CODE
// 2018-09-06 09:06:00.111 [d]

第一位是占位用的。

参考资料 Copy Chapter

• Enum value with index 0 not shown #3808
• proto3#enum
• In Go, how can I reuse a ReadCloser?

Discuss 2018 09 05 Git System (`content/discuss/2018-09-05-git-system.md`) Copy Section

title: 2018-09-05 微信讨论 date: 2018-09-05T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

[xxxxx [1 2 3 4]] 如何做到输出为[ssss 1 2 3 4] Copy Section

func main() {
	MutilParam("ssss", 1, 2, 3, 4) //[ssss 1 2 3 4]
	iis := []int{1, 2, 3, 4}
	MutilParam("xxxxx", iis) //MutilParam= [xxxxx [1 2 3 4]] 如何做到输出为[xxxx 1 2 3 4]
}

func MutilParam(p ...interface{}) {
	fmt.Println("MutilParam=", p)
}

考点：函数变参
这样的情况会在开源类库如xorm升级版本后出现Exce函数不兼容的问题。
解决方式有两个：

//方法一：interface[]
tmpParams := make([]interface{}, 0, len(iis)+1)
tmpParams = append(tmpParams, "ssss")
for _, ii := range iis {
    tmpParams = append(tmpParams, ii)
}
MutilParam(tmpParams...)
//方法二:反射
f := MutilParam
value := reflect.ValueOf(f)
pps := make([]reflect.Value, 0, len(iis)+1)
pps = append(pps, reflect.ValueOf("ssss"))
for _, ii := range iis {
    pps = append(pps, reflect.ValueOf(ii))
}
value.Call(pps)

实际上都是一样原理的，也很简单的方式处理了。

git 系统平台的选择？ Copy Section

git 系统都有哪一些？

• Github
• Gitlab
• gogs
• Gitea
• Bitbucket
• 码云
• Coding
• ？

更多讨论：

• Gitlab 资源占用太夸张了，但是确实 Gitlab 做的比较好。

云服务器至少得 4核8G

• gogs 有一个超级大的痛点：CodeReview，但是优点也很突出：速度快，资源占用少。

无法选中一行代码发表评论/注释。

• Coding 企业应该都不太敢使用吧。

时序序列告警框架 Copy Section

• bosun 是 Time Series Alerting Framework，比较轻量级，但是文档严重滞后。

• Prometheus 是用 opentsdb，有点重，还要配上 hbase，玩不转啊。

由于我们是物联网的项目，监控的指标比较多样化，tag的不确定性，应该会导致Prometheus内存耗费很大，而且prometheus采用pull的模式，虽然有pushgateway，还是挺担心的，用了prometheus后，发现业务层的监控代码也会要写的很复杂。

参考资料 Copy Chapter

• Enum value with index 0 not shown #3808
• proto3#enum
• https://github.com/bosun-monitor/bosun/issues/2301

Discuss 2018 09 14 Tips In Vscode (`content/discuss/2018-09-14-tips-in-vscode.md`) Copy Section

title: 2018-09-14 VSCode 如何代码自动补全和自动导入包 date: 2018-09-14T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

VSCode 如何代码自动补全和自动导入包 Copy Section

VSCode 必须安装以下插件：

首先你必须安装 Golang 插件，然后再给 Go 安装工具包。

在 VS Code 中，使用快捷键：command+shift+P，然后键入：go:install/update tools，将所有 16 个插件都勾选上，然后点击 OK 即开始安装。

Installing 16 tools at /Users/maiyang/develop/goworkspace//bin
  gocode
  gopkgs
  go-outline
  go-symbols
  guru
  gorename
  dlv
  godef
  godoc
  goreturns
  golint
  gotests
  gomodifytags
  impl
  fillstruct
  goplay

Installing github.com/mdempsky/gocode SUCCEEDED
Installing github.com/uudashr/gopkgs/cmd/gopkgs SUCCEEDED
Installing github.com/ramya-rao-a/go-outline SUCCEEDED
Installing github.com/acroca/go-symbols SUCCEEDED
Installing golang.org/x/tools/cmd/guru SUCCEEDED
Installing golang.org/x/tools/cmd/gorename SUCCEEDED
Installing github.com/derekparker/delve/cmd/dlv SUCCEEDED
Installing github.com/rogpeppe/godef SUCCEEDED
Installing golang.org/x/tools/cmd/godoc SUCCEEDED
Installing github.com/sqs/goreturns SUCCEEDED
Installing github.com/golang/lint/golint SUCCEEDED
Installing github.com/cweill/gotests/... SUCCEEDED
Installing github.com/fatih/gomodifytags SUCCEEDED
Installing github.com/josharian/impl SUCCEEDED
Installing github.com/davidrjenni/reftools/cmd/fillstruct SUCCEEDED
Installing github.com/haya14busa/goplay/cmd/goplay SUCCEEDED

All tools successfully installed. You're ready to Go :).

修改默认配置的方法：

在 Preferences -> Setting 然后输入 go，然后选择 setting.json，填入你想要修改的配置

• 自动完成未导入的包。

"go.autocompleteUnimportedPackages": true,

• VSCode 的一些插件需要配置代理，才能够正常安装。

"http.proxy": "192.168.0.100:1087",

• 如果你遇到使用标准包可以出现代码提示，但是使用自己的包或者第三方库无法出现代码提示，你可以查看一下你的配置项。

"go.inferGopath": true,

• 如果引用的包使用了 ( . "aa.com/text") 那这个text包下的函数也无法跳转进去，这是为什么？

修改 "go.docsTool" 为 gogetdoc，默认是 godoc。

"go.docsTool": "gogetdoc",

其他 Copy Chapter

1. 当我们在使用 import 功能的时候，如果无法通过 lint 检查，则不会执行自动 import。
2. 如果你需要自动 import 的前提是你必须把要导入的包的函数写完整。

附带我的 settings.json

{
  "go.goroot": "",
  "go.gopath": "",
  "go.inferGopath": true,
  "go.autocompleteUnimportedPackages": true,
  "go.gocodePackageLookupMode": "go",
  "go.gotoSymbol.includeImports": true,
  "go.useCodeSnippetsOnFunctionSuggest": true,
  "go.useCodeSnippetsOnFunctionSuggestWithoutType": true,
  "go.docsTool": "gogetdoc",
}

参考资料 Copy Chapter

1. GOPATH in the VS Code Go extension
2. VSCode Golang 开发配置之代码提示
3. Use gogetdoc instead of godef and godoc #622

Discuss 2018 09 18 Benchmark Tools (`content/discuss/2018-09-18-benchmark-tools.md`) Copy Section

title: 2018-09-18 压测接口性能的框架，大家有没有推荐 date: 2018-09-18T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

压测接口性能的框架，大家有没有推荐? Copy Section

• wrk
• hey
• vegeta

Discuss 2018 09 19 Wechat Discuss (`content/discuss/2018-09-19-wechat-discuss.md`) Copy Section

title: 2018-09-19 微信讨论 date: 2018-09-19T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

时间：2018-09-19

Producer to Consumer via channel Copy Chapter

这段code有问题，可能程序跑完了，buffer中还存在数据，就丢失了。

package main

import (
	"fmt"
)

const maxBufSize = 3
const numToProduce = 1000

var finishedProducing = make(chan bool)
var finishedConsuming = make(chan bool)

var messageBuffer = make(chan int, maxBufSize)

func produce() {
	for i := 0; i < numToProduce; i++ {
		messageBuffer <- i
	}

	finishedProducing <- true
}

func consume() {
	for {
		select {
		case message := <-messageBuffer:
			fmt.Println(message)
		case <-finishedProducing:
			finishedConsuming <- true
			return
		}
	}
}

func main() {
	go produce()
	go consume()
	<-finishedConsuming

	fmt.Println("All go routines ended")
}

原因 Copy Chapter

buffer中的消息可能没有被处理

解决办法 Copy Chapter

应该用for range从channel 里取，produce 那里直接关闭messageChannel就行了。 （AMan）

package main

import (
	"fmt"
)

const maxBufSize = 3
const numToProduce = 1000

// var finishedProducing = make(chan bool)
var finishedConsuming = make(chan bool)

var messageBuffer = make(chan int, maxBufSize)

func produce() {
	for i := 0; i < numToProduce; i++ {
		messageBuffer <- i
	}

	close(messageBuffer)
}

func consume() {
	for message := range messageBuffer {
		fmt.Println(message)
	}
	finishedConsuming <- true

}

func main() {
	go produce()
	go consume()
	<-finishedConsuming

	fmt.Println("All go routines ended")
}

提升 Copy Chapter

可以使用 make(chan struct{}) 代替 make(chan bool)

Discuss 2018 09 28 Return Value In Waitgroup (`content/discuss/2018-09-28-return-value-in-waitgroup.md`) Copy Section

title: 2018-09-28 goroutine 中怎么得到返回值 date: 2018-09-28T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

时间：2018-09-28

goroutine 中怎么得到返回值？ Copy Chapter

package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	fmt.Println("开始。。。")
	wg.Add(2)

	time1 := time.Now()

	go f1(1, 4)
	go f2(2, 5)

	wg.Wait()

	time2 := time.Since(time1)
	fmt.Printf("cost:%v\n", time2)
}

func f1(n1, n2 int) int {
	time.Sleep(time.Second)
	wg.Done()
	fmt.Println("f1")
	return n1 + n2
}

func f2(n1, n2 int) int {
	time.Sleep(time.Second)
	wg.Done()
	fmt.Println("f2")
	return n1 + n2
}

如果我想要获取 f1 ，f2 的返回值，有什么办法？

解决方案1 Copy Chapter

package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	fmt.Println("开始。。。")
	wg.Add(2)

	time1 := time.Now()
	var x int
	go func() {
		x = f1(1, 4)
		wg.Done()
	}()

	var y int
	go func() {
		y = f2(2, 5)
		wg.Done()
	}()
	wg.Wait()
	fmt.Printf("f1:%d\n", x)
	fmt.Printf("f2:%d\n", y)

	time2 := time.Since(time1)
	fmt.Printf("cost:%v\n", time2)
}

func f1(n1, n2 int) int {
	time.Sleep(time.Second)

	fmt.Println("f1")
	return n1 + n2
}

func f2(n1, n2 int) int {
	time.Sleep(time.Second)
	fmt.Println("f2")
	return n1 + n2
}

这里需要注意的地方就是，我们要读取值，必须等待 goroutine 执行完之后才可以。

解决方案2 Copy Chapter

WaitGroup+Channel 结合的方式：

package main

import (
	"fmt"
	"sync"
	"time"
)

// R return value
type R struct {
	name string
	ret  int
}

func main() {
	fmt.Println("开始。。。")

	time1 := time.Now()
	var wg sync.WaitGroup
	retCh := make(chan *R, 2)
	wg.Add(1)
	go func() {
		retCh <- f1(1, 4)
		wg.Done()
	}()

	wg.Add(1)
	go func() {
		retCh <- f2(2, 5)
		wg.Done()
	}()
	wg.Wait()
	close(retCh)
	fmt.Println("after wait ...")
	for r := range retCh {
		fmt.Printf("func name:%s, return:%d\n", r.name, r.ret)
	}

	time2 := time.Since(time1)
	fmt.Printf("cost:%v\n", time2)
}

func f1(n1, n2 int) *R {
	time.Sleep(time.Second)

	fmt.Println("f1")
	return &R{
		name: "f1",
		ret:  n1 + n2,
	}
}

func f2(n1, n2 int) *R {
	time.Sleep(time.Second)

	fmt.Println("f2")
	return &R{
		name: "f2",
		ret:  n1 + n2,
	}
}

参考资料 Copy Chapter

1. sync.WaitGroup

A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. Then each of the goroutines runs and calls Done when finished. At the same time, Wait can be used to block until all goroutines have finished.

A WaitGroup must not be copied after first use.

Discuss 2018 10 18 EncOp (`content/discuss/2018-10-18-encOp.md`) Copy Section

title: 2018-10-18 encOp 是在哪里实现的呢？ date: 2018-10-18T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

encOp 是在哪里实现的呢？ Copy Chapter

encode.go文件中的这行代码是对数据进行编码么,具体怎么实现的,在哪里知道么?
instr.op(instr, state, reflect.Value{})

func (enc *Encoder) encode(b *encBuffer, value reflect.Value, ut *userTypeInfo) {
	defer catchError(&enc.err)
	engine := getEncEngine(ut, nil)
	...
}

点击进入 getEncEngine -> buildEncEngine -> compileEnc -> encOpFor

func encOpFor(rt reflect.Type, inProgress map[reflect.Type]*encOp, building map[*typeInfo]bool) (*encOp, int) {
	...
	var op encOp
	if int(k) < len(encOpTable) {
		op = encOpTable[k]
	}
	...
}
...
var encOpTable = [...]encOp{
	reflect.Bool:       encBool,
	reflect.Int:        encInt,
	reflect.Int8:       encInt,
	reflect.Int16:      encInt,
	reflect.Int32:      encInt,
	reflect.Int64:      encInt,
	reflect.Uint:       encUint,
	reflect.Uint8:      encUint,
	reflect.Uint16:     encUint,
	reflect.Uint32:     encUint,
	reflect.Uint64:     encUint,
	reflect.Uintptr:    encUint,
	reflect.Float32:    encFloat,
	reflect.Float64:    encFloat,
	reflect.Complex64:  encComplex,
	reflect.Complex128: encComplex,
	reflect.String:     encString,
}

点击每个 value 就可以查看其实现了。

Discuss 2018 11 08 Address Operators (`content/discuss/2018-11-08-address_operators.md`) Copy Section

title: 2018-11-08 Address operators date: 2018-11-08T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

Address_operators Copy Chapter

package main

import (
   "fmt"
   "math"
)

type abser interface {
   Abs() float64
}

type onef float64

func (one onef) Abs() float64{
   return math.Pi
}

func main(){
   var a,b  abser
   a = &onef(3.14)
   aa := onef(3.14)
   b = &aa
   fmt.Println(a.Abs())
   fmt.Println(b.Abs())
}

为什么 a = &onef(3.14) 会报错，而 aa := onef(3.14) 是可以的呢？

For an operand x of type T, the address operation &x generates a pointer of type *T to x. The operand must be addressable, that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array. As an exception to the addressability requirement, x may also be a (possibly parenthesized) composite literal. If the evaluation of x would cause a run-time panic, then the evaluation of &x does too.

对于类型为 T 的操作数 x，地址操作 ＆x 生成类型为 *T 到 x 的指针。操作数必须是可寻址的，即，变量，指针间接或切片索引操作;
或可寻址结构操作数的字段选择器;
或者可寻址数组的数组索引操作。
作为可寻址性要求的例外，x也可以是（可能带括号的）复合文字。
如果x的评估会导致运行时恐慌，那么＆x的评估也会发生。

For an operand x of pointer type *T, the pointer indirection *x denotes the variable of type T pointed to by x. If x is nil, an attempt to evaluate *x will cause a run-time panic.

对于指针类型* T的操作数x，指针间接* x表示由x指向的类型T的变量。如果x为nil，则尝试评估* x将导致运行时出现紧急情况。

参考资料 Copy Chapter

1. Go 夜读第一期 - cannot take address of temporary variables
2. https://golang.org/ref/spec#Address_operators

Discuss 2018 11 08 Aws Ec2 Ssh Login Problem (`content/discuss/2018-11-08-aws-ec2-ssh-login-problem.md`) Copy Section

title: 2018-11-08 aws ec2实例无法连接登录问题 date: 2018-11-08T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-11-08

aws ec2实例无法连接登录问题 Copy Chapter

在AWS上注册一个账号,然后创建一个免费试用期限的虚拟机,虚拟机成功创建并启动之后,我们通过SSH登录这台虚拟机出现无法连接的问题.

连接方式aws console页面会提示你如何连接,如下:

# 1. 创建虚拟机的时候会让你生成一个pem秘钥文件作为登录认证,把这个xxx.pem文件放到自己的机器上并设置400权限
chmod 400 wpc-secret.pem

# 2. 登录(注意我的是aws虚拟机是centos系统需要ec2-user用户登录,加-v参数显示登录过程详细信息)
ssh -i "wpc-secret.pem" [email protected] -v

# 3. 我们会发现无法登录,超时登录后断开了,是因为默认ec2上面创建的虚拟机在默认情况下，默认安全组不允许传入SSH流量。所以你需要在ec2 console中的左侧菜单栏找到安全组然后添加SSH类型的入站和出站规则即可
略...

# 4. 重新尝试登录,一般情况先就成功登录上了
ssh -i "wpc-secret.pem" [email protected] -v
...

Discuss 2018 11 09 Force To Use Keyed Struct Literals (`content/discuss/2018-11-09-force-to-use-keyed-struct-literals.md`) Copy Section

title: 2018-11-09 强制使用字段命名方式初始化结构体 date: 2018-11-09T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-11-09

强制使用字段命名方式初始化结构体 Copy Chapter

在定义结构体时,加入一个非导出且大小为0的字段, 编译器会强制开发者使用字段命名的方式初始化结构体, 而不能按顺序来赋值.

这个小技巧利用了包的非导出字段可见性, 所以只能在不同包下初始化结构体才有用.

// foo.go
package foo

type Config struct {
	_    [0]int
	Name string
	Size int
}

// main.go
package main

import "foo"

func main() {
    //_ = foo.Config{[0]int{}, "bar", 123}
    // doesn't compile
    // 报错信息:implicit assignment of unexported field 'flag' in foo.Config literal

	_ = foo.Config{Name: "bar", Size: 123} // compile okay
}

不要把非导出且大小为0的字段放在结构体的最后面, 可能会导致多分配内存.

参考资料 Copy Chapter

1. How to force package users to use struct composite literals with field names?
2. Why does the final field of a zero-sized type in a struct contribute to the size of the struct sometimes?
3. golang 内存分析之字节对齐规则

Discuss 2018 11 29 Config In Go (`content/discuss/2018-11-29-config-in-go.md`) Copy Section

title: Golang 用什么配置中心管理服务 date: 2018-11-29T17:13:46+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-11-29

Golang 用什么配置中心管理服务？ Copy Chapter

• etcd

https://juejin.im/post/5b7e8b82f265da432e75c7c4

• Qconf

Discuss 2018 12 04 Change To Go (`content/discuss/2018-12-04-change-to-go.md`) Copy Section

title: 实打实的 Go 项目，但是 Github 却统计为 JavaScript 怎么办？ date: 2018-12-04T17:13:46+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-12-04

原理 Copy Chapter

Github 采用 Linguist 来自动识别你的代码，然后判断属于哪一种语言。

问题 Copy Chapter

但是我是一个 Go 相关的文档或者 Go Web 工程项目，肯定希望在搜索 Go 语言的时候，也能包括我，并且显示项目所属语言为 Go。

但是默认情况下，你肯定会失望。。。可能还会吐槽：为什么 Github 不提供一个选择项目所属语言呢？

针对这个问题，我的思考是，Github 就是想让大家 hack 一点。

解决方法 Copy Chapter

1. 在项目中增加更多的你所想要归属的语言的代码（综合性项目，最好是采用这种方式）。
2. 在项目中添加 .gitattributes

*.js linguist-language=go
*.java linguist-language=go
...

这种方式会导致你处理的后缀语言也不会在项目中被标识出来了。

Discuss 2018 12 04 Wechat Discuss (`content/discuss/2018-12-04-wechat-discuss.md`) Copy Section

title: "2018-12-04 微信讨论" date: 2018-12-04T17:13:46+08:00 Copy Chapter

来源：『Go 夜读』微信群

json 解析结构体断言问题 Copy Chapter

package main

import (
	"encoding/json"
)

type Msg struct {
	Id     int           `json:"id"`
	Params []interface{} `json:"params"`
}

type Employee struct {
	Name string `json:"name"`
}

func main() {
	b := []byte(`{"id":111,"params":["boss",[{"name":"a"},{"name":"b"}]]}`)
	msg := &Msg{}
	json.Unmarshal(b, msg)

	_ = msg.Params[0].(string)
	_ = msg.Params[1].([]Employee) //无法直接断言?
}

对于复杂多变的结构体, 经常会用 interface 作为类型,然后根据情况断言

上面的例子运行起来会报错, 原因是 json.Unmarshal 之后无法再断言成具体的结构体 (虽然结构体和 map[string]interface{}可以互转)

解决方案1️⃣(非最优): Copy Section

把想要断言成具体 struct 的字段重新json.Marshal 和 json.Unmarshal,会多操作一步不推荐

newB, _ := json.Marshal(msg.Params[1])
var employee []Employee
json.Unmarshal(newB, &employee)

解决方案2️⃣: Copy Section

把 interface{}类型改为 json.RawMessage ,可以延迟该字段的解析, 在用到的时候进行二次解析

package main

import (
	"encoding/json"
	"log"
)

type Msg struct {
	Id     int               `json:"id"`
	Params []json.RawMessage `json:"params"`
}

type Employee struct {
	Name string `json:"name"`
}

func main() {
	b := []byte(`{"id":111,"params":["boss",[{"name":"a"},{"name":"b"}]]}`)
	msg := &Msg{}
	json.Unmarshal(b, msg)

	var boss string
	json.Unmarshal(msg.Params[0], &boss)
	log.Println(string(boss))

	var employee []Employee
	json.Unmarshal(msg.Params[1], &employee)
	log.Println(employee)
}

Discuss 2018 12 07 Wechat Discuss (`content/discuss/2018-12-07-wechat-discuss.md`) Copy Section

title: "2018-12-07 微信讨论" date: 2018-12-07T23:13:46+08:00 Copy Chapter

来源：『Go 夜读』微信群

应该还是负数问题，你实验一下

下面这种情况的负数报错是在 build 阶段报的：

errMake := make([]byte, 64-22*5)  // negative len argument in make([]byte)

下面这种情况的负数，编译时不知道，是在运行时的报错：

errMake := make([]byte, 64-len(testStr)*5)  // runtime error: makeslice: len out of range

Discuss 2018 12 11 Wechat Discuss (`content/discuss/2018-12-11-wechat-discuss.md`) Copy Section

title: "2018-12-11 微信讨论" date: 2018-12-11T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

时间：2018-12-11

Golang module初始化 Copy Chapter

使用go mod命令进行初始化：

go mod init [module name]

如：go mod init cmpp

Golang module文件 Copy Chapter

调用go mod init会自动生成go.mod文件，使用如下：

module tx

require github.com/sirupsen/logrus v1.2.0

require (
	github.com/acroca/go-symbols v0.0.0-20180523203557-953befd75e2 // indirect
	github.com/ramya-rao-a/go-outline v0.0.0-20181122025142-7182a932836a // indirect
	github.com/rogpeppe/godef v1.1.0 // indirect
	github.com/sqs/goreturns v0.0.0-20181028201513-538ac6014518 // indirect
	github.com/stamblerre/gocode v0.0.0-20181212030458-2f9d39d8f31d // indirect
)

replace (
	golang.org/x/crypto v0.0.0-20180904163835-0709b304e793 => github.com/golang/crypto v0.0.0-20181203042331-505ab145d0a9 // indirect
	golang.org/x/net v0.0.0 => github.com/golang/net v0.0.0-20181207154023-610586996380 // indirect
	golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33 => github.com/golang/sys v0.0.0-20181213200352-4d1cda033e06 // indirect
	golang.org/x/text v0.0.0 => github.com/golang/text v0.3.1-0.20181211190257-17bcc049122f // indirect
	golang.org/x/tools v0.0.0-20181130195746-895048a75ecf => github.com/golang/tools v0.0.0-20181213210126-fe2443f7b950 // indirect
)

indirect的意思是指这个package被子module/package依赖了，但是main module并没有直接import使用，也就是所谓的间接引用。

mod版本号解读 Copy Chapter

github.com/acroca/go-symbols v0.0.0-20180523203557-953befd75e2含义：

前面部分是包的名字，也就是import时需要写的部分，而空格之后的是版本号，版本号遵循如下规律：
vX.Y.Z-pre.0.yyyymmddhhmmss-abcdefabcdef
vX.0.0-yyyymmddhhmmss-abcdefabcdef
vX.Y.(Z+1)-0.yyyymmddhhmmss-abcdefabcdef
vX.Y.Z

也就是版本号+时间戳+hash，我们自己指定版本时只需要制定版本号即可，没有版本tag的则需要找到对应commit的时间和hash值。
默认使用最新版本的package。

这个组合的版本号可称为伪版本号。

总不能让大家记住每个包的伪版本号吧？显然不太现实，初始化mod文件可以如下写：

require github.com/sirupsen/logrus latest

然后运行 go run main.go ，会主动更新版本号，如果运行出现提示不支持latest，可将latest更改为master。
注：如果的确获取不到版本号，实在不知道的话（比如需翻墙才可获取的包），就试试v0.0.0

mod文件格式化 Copy Chapter

使用如下命令:

go mod edit -fmt

1.会删除冗余的类库
2.自动格式化，并排序类库
注：mod文件可以有多个require，括号要与关键词隔开。

问题一：Golang module下golang.org如何处理被墙 Copy Chapter

系统提示

go: golang.org/x/[email protected]: unrecognized import path "golang.org/x/sys" (https fetch: Get https://golang.org/x/sys?go-get=1: dial tcp 216.239.37.1:443: i/otimeout)
go: golang.org/x/[email protected]: unrecognized import path "golang.org/x/crypto" (https fetch: Get https://golang.org/x/crypto?go-get=1: dial tcp 216.239.37.1:443: i/o timeout)
go: error loading module requirements

解决方案

在go.mod进行如下设置：

replace (
    golang.org/x/crypto v0.0.0-20180820150726-614d502a4dac => github.com/golang/crypto v0.0.0-20180820150726-614d502a4dac
    golang.org/x/net v0.0.0-20180821023952-922f4815f713 => github.com/golang/net v0.0.0-20180826012351-8a410e7b638d
    golang.org/x/text v0.3.0 => github.com/golang/text v0.3.0
    golang.org/x/sys v0.3.0=>github.com/golang/sys v0.3.0
)

问题二：初始化权限设置 Copy Chapter

系统提示

go: writing stat cache:, permission denied

解决方案

sudo chown -R $(whoami):admin /Users/zhushuyan/go/pkg && sudo chmod -R g+rwx /Users/zhushuyan/go/pkg

Discuss 2018 12 25 MacOS Time Synchronization (`content/discuss/2018-12-25-macOS-time-synchronization.md`) Copy Section

title: 2018-12-25 MacOS Time Synchronization date: 2018-12-25T16:36:45+08:00 Copy Chapter

来源: Wechat discuss

MacOS Time Synchronization Copy Chapter

今天在启动 Geth (以太坊私链节点)的时候，出现了以下的错误。在比较后发现本机时间落后了北京时间近一分钟。

在搜索解决方案的时候，发现在 macOS Mojave 里面 ntpdate 已经废弃了。
改用了sntp，在Terminal输入以下的命令，即可同步。

sudo sntp -sS time.asia.apple.com

系统设置建议 Copy Section

• 1、自动设置日期与时间
• 2、时区不要自动设定，选择中国北京，因为不同地区的时间会有误差。

参考资料 Copy Chapter

1. https://apple.stackexchange.com/questions/117864/how-can-i-tell-if-my-mac-is-keeping-the-clock-updated-properly

Discuss 2019 01 10 Anlayze Range (`content/discuss/2019-01-10-anlayze-range.md`) Copy Section

title: 2019-01-10 关于range的一些不易察觉的"坑" date: 2019-01-10T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

1. 以下代码最终的结果是什么? Copy Section

func main(){
	sli := []int{6,7,8}
	for i := range sli {
		sli = append(sli,666)
		fmt.Println(i)
	}
}

// Output:

面试时遇到的一个问题,
这段代码会形成死循环吗?

回来之后试了一下出乎意料:
输出结果为:

0
	1
	2

看上去 for 循环的次数,在进入循环体前已经确定了,且次数为 range 后 len(sli)

实际上,range 为 golang 的语法糖,其实际执行相当于

func main()  {
	sli := []int{6,7,8}
	len_sli := len(sli)
	for index := 0 ; index < len_sli; index++ {
		sli = append(sli,666)
		fmt.Println(index)
	}
}

即在进入循环之前,控制循环次数的这个 len_sli 参数已经确定;

在循环体内对原切片进行 append 操作,并不会影响 len_sli 的值

2. 写出以下代码的输出: Copy Section

package main

const N  = 3

func main(){
	m := make(map[int]*int)
	
	for i := 0; i < N; i++ {
		m[i] = &i
	}
	
	for _, v := range m {
		print(*v)
	}
}

初步分析:

• 在第一个循环中为m赋值,键名0,1,2分别对应着键值0,1,2的内存地址
• 在第二个循环中迭代m,每次循环用*取出指针键值对应内存地址里存的值
• 初步分析,结果应该是0,1,2

运行结果为:

3
	3
	3

结果却是3,3,3

• 我们加一下注释代码再来看:

func main()  {
   	m := make(map[int]*int)
   
   	for i := 0; i < 3; i++{
   		m[i] = &i //A
   		fmt.Println("&i的值是:",&i)
   		fmt.Println("i的值是:",i)
   	}
   	for c,v := range m {
   		fmt.Println(c)
   		time.Sleep(1e9)
   		fmt.Println(*v)
   		time.Sleep(1e9)
   	}
}

结果如下:

&i的值是: 0xc420016468
i的值是: 0
&i的值是: 0xc420016468
i的值是: 0
&i的值是: 0xc420016468
i的值是: 0
0
3
1
3
2
3

即在迭代中m的三个元素的指针相同,都指向了最后一个迭代对象的地址,在此即3的值

• 如果在迭代体中需要访问数组/map元素的指针，那么务必小心.这类 bug 无形极难轻易寻获

• 改进办法:引入中间变量,如下:

func main(){
	m := make(map[int]*int)
	
	for i := 0; i < 3; i++ {
		x := i
		fmt.Println(x)
		fmt.Println(&x)
		m[i] = &x
		fmt.Println("&i的值是:",&i)
		fmt.Println("i的值是:",i)
	}
	
	for c,v := range m {
		
		fmt.Println(c)
		time.Sleep(1e9)
		fmt.Println(*v)
		time.Sleep(1e9)
	}
}

输出为:

0
0xc420016470
&i的值是: 0xc420016468
i的值是: 0
1
0xc420016490
&i的值是: 0xc420016468
i的值是: 1
2
0xc4200164a8
&i的值是: 0xc420016468
i的值是: 2
0
0
1
1
2
2

• 即此处v其实是一个全局变量,只分配了一次内存地址

总结: Copy Chapter

关于range,有两点需要注意:

• 一个是长度在循环之前就已经确定
• 另一个是迭代出的值是全局变量~

Discuss 2019 02 20 Bigdecimal Show String (`content/discuss/2019-02-20-bigdecimal-show-string.md`) Copy Section

title: 2019-02-20 浮点数如何输出 date: 2019-02-20T00:00:00+08:00 Copy Chapter

来源: Wechat discuss

将数据序列化为json的时候，怎么让序列化后的 json 里面不要使用科学计数法 Copy Section

json.Marshal 转出来的json怎么能不让转成科学计数法 大家有解决办法吗？ Copy Section

dec := decimal.NewFromFloat(0.000001)
fmt.Println(dec.String())

参考资料 Copy Chapter

1. shopspring/decimal

Discuss 2019 03 07 Wechat Discuss (`content/discuss/2019-03-07-wechat-discuss.md`) Copy Section

title: "2019-03-07 微信讨论" date: 2019-03-07T10:51:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

1 Goland中println和fmt.Print乱序原因 Copy Chapter

Question: 下面的代码，在goland上运行后，为何输出顺序不确定？但是使用命令行go run xxx运行，输出顺序却是确定的？

package main

import "fmt"

func main() {
    println("hello")
    println("world")
    fmt.Print("go\n")
}

输出结果：
hello
world
go

或是：
go
hello
world

Answer:

println输出流是stderr，而fmt.Print输出流是stdout。而goland应该是区分stderr和stdout的（输出结果中stderr为红色），这种顺序不确定应该是goland自身处理stderr/stdout输出的时候导致的。因此通过非goland（比如console）方式运行该代码，顺序是确定的。

reference：

• golang i use fmt.Println() after println() but
• 为什么Go自带的日志默认输出到os.Stderr？

2 Go 终端输出彩色文字方法 Copy Chapter

2.1 色彩编码 Copy Section

ANSI转义序列是一种带内信号的转义序列标准，用于控制视频文本终端上的光标位置/颜色和其他选项。在文本中嵌入确定的字节序列，大部分以ESC转义字符和[字符开始，终端会把这些字节序列解释为相应的指令，而不是普通的字符编码。

其中有专门控制字符颜色的控制符。一般由ESC[开始，中间包含若干个（包括0个）参数字节，以及一个最终字节组成。例如：\x1b[37;44;4;1m hello go \x1b[0m，代表输出的文字hello go的格式是：蓝色背景（44），灰色字体（37），带下滑下（4）并且加粗（1），go 语言代码如下：

package main

import "fmt"

func main() {
    fmt.Printf("\x1b[37;44;4;1m hello go \x1b[0m")
}

其中：

- \x1b 标志字符，代表转义序列开始，其实就是0x1B
- [ 转义序列的开始符
- 以 ; 分割的数字是控制字符
- m 代表结束控制字符序列

常用的文本样式控制符如下：

1位颜色编码

2.2 例子 Copy Section

通过颜色控制，我们可以输出带颜色的log，例子如下：

package main

import (
	"fmt"
	"time"
)

const (
	color_red = uint8(iota + 91)
	color_green
	color_yellow
	color_blue
	color_magenta

	succ = "[succ]"
	error = "[error]"
	warn = "[warn]"
	info = "[info]"
	debug = "[debug]"
)

func red(s string) string {
	return fmt.Sprint("\x1b[%dm%s\x1b[0m", color_red, s)
}

func green(s string) string {
	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_green, s)
}

func yellow(s string) string {
	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_yellow, s)
}

func blue(s string) string {
	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_blue, s)
}

func magenta(s string) string {
	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_magenta, s)
}

func Success(format string, a ... interface{}) {
	prefix := green(succ)
	fmt.Println(formatLog(prefix), fmt.Sprintf(format, a ...))
}

func Error(format string, a ... interface{}) {
	prefix := red(error)
	fmt.Println(formatLog(prefix), fmt.Sprintf(format, a...))
}

func Warning(format string, a ... interface{}) {
	prefix := magenta(warn)
	fmt.Println(formatLog(prefix), fmt.Sprintf(format, a...))
}

func Info(format string, a ... interface{}) {
	prefix := blue(info)
	fmt.Println(formatLog(prefix), fmt.Sprintf(format, a...))
}

func Debug(format string, a ... interface{}) {
	prefix := yellow(debug)
	fmt.Println(formatLog(prefix), fmt.Sprintf(format, a...))
}

func formatLog(prefix string) string {
	return time.Now().Format("2006/01/02 15:04:05") + "" + prefix + ""
}

func main() {
	Debug("%s", "hello, go")
}

2.3 参考 Copy Section

• ANSI转义序列
• 教你写一个color日志库
• 在终端中输出彩色文字
• IntelliJ IDEA 安装 Grep Console 自定义控制台输出多颜色格式

Discuss 2019 03 08 Wechat Discuss (`content/discuss/2019-03-08-wechat-discuss.md`) Copy Section

title: "2019-03-08 微信讨论" date: 2019-03-08T21:00:00+08:00 Copy Chapter

读写锁引入 Copy Chapter

有下面一段程序，面试官问这段程序有什么问题？

type Store struct {
    a string
    b string

    sync.RWMutex
}

func (s *Store) GetA() string {
    fmt.Println("get a")
    s.RLock()
    fmt.Println("get a2")
    defer s.RUnlock()

    return s.a
}

func (s *Store) GetAB() (string, string) {
    fmt.Println("get ab")
    s.RLock()
    fmt.Println("get ab2")
    defer s.RUnlock()

    return s.GetA(), s.b
}

func (s *Store) Write(a, b string) {
    fmt.Println("write")
    s.Lock()
    defer s.Unlock()
    fmt.Println("write2")

    s.a = a
    s.b = b
}

1. 看到这段程序程序，首先想到的是读写锁的问题；
2. 其次，看 Store 这个结构体，各个函数都定义的是指针函数。那就说明：不存在读写锁的 copy 过程；
3. GetAB 方法中通过调用 GetA 方法，在 s.RUnlock 前通过调用 s.GetA，又做了一次读写锁上锁 s.RLock，但是读锁可以多次上锁，所以单看这里没什么问题；
4. 然后，想到会不会 Write 和 GetAB 并发调用的时候会存在问题呢？思考了一会，觉得没问题，就放弃了。

以上，是面试时整个思路。

回头，越想越觉得这里哪里有问题，就在夜读群里求教了一下，群里大神发了一篇读写锁优先级的文章，然后给了一段测试样例，瞬间豁然开朗。

main函数逻辑如下：

func main() {
    store := Store{}
    wg := sync.WaitGroup{}
    wg.Add(2)
    go func() {
        defer wg.Done()
        for i := 1; i < 10000; i += 1 {
            fmt.Println("main write ", i)
            store.Write("111", "1111")
        }
    }()
    go func() {
        defer wg.Done()
        for i := 1; i < 10000; i += 1 {
            fmt.Println("main get ab", i)
            store.GetAB()
        }
    }()
    wg.Wait()
}

执行结果

main get ab 12  //main函数读取ab
get ab          //进入 s.GetAB 函数
main write  1   //main 函数写数据
write           //进入 s.Write 函数
write2          //获取写锁
main write  2
....            //写锁一直抢占
....
main write  13  //main 函数写数据
write           //进入 s.Write 函数
write2          //获取写锁
main write  14  
write
write2
get ab2         //之前 get ab 12 才获得读锁
get a           //进入 GetA 
get a2          //获取读锁
main get ab 13  //main函数 get ab
get ab          //进入 s.GetAB 函数
get ab2         //获取读锁
main write  15  //注意⚠️ 这个时候写数据开始了
write           //进入 Write 函数，后面尝试获取写锁
get a           //这个时候 GetAB 进入了 GetA，尝试获取读锁
fatal error: all goroutines are asleep - deadlock!  //出现了死锁

分析：

GetAB       |            GetA               |                Write
                |                               |
r0 占用读锁      |                               |
                |                               |    w0 尝试获取写锁 等待r0释放读锁
                |   r1 尝试获取读锁，排在w0后面     |

由于读写锁的优先级，读锁和写锁同时竞争时，读锁要排在写锁后面，导致了 r1 竞争 w0的锁，w0竞争r0，r0执行不下去，最后死锁。

读写锁底层 Copy Chapter

读写锁前置条件：

1. 读写互斥，但是读读不互斥；
2. 读、写锁都不会出现饥饿；
3. 保证读上锁数量与解锁数量一致；

可以思考下，如果让你设计一个这样的锁，你会怎么设计？

go中读写锁的结构，如下：

type RWMutex struct {
    w           Mutex  // 用来保证同一时间只有一个写锁能够抢到锁
    writerSem   uint32 // 写锁信号量，在读锁全部解锁时通知阻塞的写锁
    readerSem   uint32 // 读锁信号量，在写锁解锁时通知阻塞的读操作
    readerCount int32  // 等待、已上锁的读锁数量
    readerWait  int32  // 写锁获得锁前，已经上锁的读锁数量
}

读锁逻辑 Copy Section

首先，看一下读上锁逻辑：

func (rw *RWMutex) RLock() {
    ...
    if atomic.AddInt32(&rw.readerCount, 1) < 0 {
        // A writer is pending, wait for it.
        runtime_SemacquireMutex(&rw.readerSem, false)
    }
    ...
}

上面，上读锁逻辑获试图获取读锁数量原子性加一： atomic.AddInt32(&rw.readerCount, 1)。自增操作返回值如果小于0，则阻塞等待信号量 readerSem 唤醒。

疑问：

1. 什么情况下 readerCount 小于0；
2. runtime_SemacquireMutex 不会造成读读互斥么？
3. 如何保证读、写互斥？

再来看一下，读解锁逻辑：

func (rw *RWMutex) RUnlock() {
    ...
    if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 { 
        if r+1 == 0 || r+1 == -rwmutexMaxReaders {
            race.Enable()
            throw("sync: RUnlock of unlocked RWMutex")
        }

        // A writer is pending.
        if atomic.AddInt32(&rw.readerWait, -1) == 0 {
            // The last reader unblocks the writer.
            runtime_Semrelease(&rw.writerSem, false)
        }
    }
    ...
}

解锁逻辑：先对 atomic.AddInt32(&rw.readerCount, -1) 进行原子性减一操作。

• r大于 0 ：直接释放锁完成；
• r小于 0 ：进行读锁数量一致性判断，atomic.AddInt32(&rw.readerWait, -1) 针对 readerWait 原子性减一后判断是否为 0，为 0 则唤起写锁信号量；

与读加锁类似，同样有 atomic.AddInt32(&rw.readerCount, -1) 小于 0 判断。可以有结论 rw.readerCount 小于 0，为写锁上锁的充要条件，后面分析写锁时进行验证。

解决了的问题：

1. 释放读锁，读锁全部释放后唤起写锁；
2. 上锁与解锁数量一致性保证；

疑问：

1. readerCount 修改成一个负数？如何保证这个负数足够小呢？

写锁逻辑 Copy Section

先上代码：

func (rw *RWMutex) Lock() {
    ...
    // First, resolve competition with other writers.
    rw.w.Lock()
    // Announce to readers there is a pending writer.
    r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
    // Wait for active readers.
    if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
        runtime_SemacquireMutex(&rw.writerSem, false)
    }
    ...
}

写上锁逻辑：

1. 首先，互斥量上锁，保证只有一个写锁加锁成功。
2. 然后，令 readerCount 原子性减去 rwmutexMaxReaders（这是个常量，具体定义 const rwmutexMaxReaders = 1 << 30）。这里可以验证之前猜想，rw.readerCount 小于0，是持有锁的充要条件。
   • atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders 返回结果是在写锁获取前，已持有读锁的数量 r。
     • r=0，说明没有读锁；
     • r<0，只有在读解锁数量>读加锁数量，或写锁多次时发生；第一个情况，读解锁会 check；第二种情况，mutex 保证同时只有一个写锁；
     • r>0，存在读锁；
3. 再进行 r!=0 判断（即存在读锁）。原子性操作 atomic.AddInt32(&rw.readerWait, r)，记录需要等待的读锁数量，然后等待writerSem唤醒。

最终，保证：1. 写锁唯一性；2. 等待读锁完全释放；3. 阻塞后面读锁的获取；

再来看一下，写锁解锁逻辑：

func (rw *RWMutex) Unlock() {
    ...
    // Announce to readers there is no active writer.
    r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
    if r >= rwmutexMaxReaders {
        race.Enable()
        throw("sync: Unlock of unlocked RWMutex")
    }
    // Unblock blocked readers, if any.
    for i := 0; i < int(r); i++ {
        runtime_Semrelease(&rw.readerSem, false)
    }
    // Allow other writers to proceed.
    rw.w.Unlock()
    ...
}

解锁逻辑：

1. 原子性操作 atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)。这里，能够看到两个隐含的点：
   • 原子操作结束后，如果有其他读锁试图获取读锁，不需要阻塞；
   • 这个时候其他线程还是不能够获取写锁；
   • 即：写锁释放锁时，读锁要比写锁优先级高；
2. 原子操作返回值，是当前读锁数量。包括在写锁前读锁（写锁未完全获得情况下写锁解锁），和写锁后阻塞读锁；然后 runtime_Semrelease 唤起阻塞着的读锁。
   • runtime_Semrelease > runtime_SemacquireMutex 会不会存在问题？验证过不会。
3. 然后写锁释放；

总结 Copy Chapter

通过分析，可以得出结论：

1. 写锁释放过程中，读锁优先级要高于写锁；
2. 读锁加锁后，写锁可以进入加锁过程，但是要等待之前读锁释放；即，并不少写锁优先级高于写锁，而是在读锁已经上锁，或没有持有读写锁的协程条件下，读写锁都有机会获取锁；

所以，针对之前的面试题，读锁嵌套读锁，在有写锁的时候，依据结论2会发生死锁。

通过上面分析，存在待验证问题：

1. 一个协程个已获取读锁，另个协程试图获取写锁，还有一个协程在完全获取写锁前调用Unlock，再一个协程释放读锁，按顺序进行流程。会发生死锁具体可以自己分析（写锁信号量永远阻塞）；

2. 一个协程已上写锁锁，一个协程试图获取读锁，然后另一个协程释放读锁，最后一个协程释放写锁，同样会发生死锁（读信号量永远阻塞）；

在以后用锁的时候不管有没有优先级，都要时刻记住死锁的四个必要条件：

1. 互斥条件：一个资源每次只能被一个进程使用。
2. 锁的不可抢占：进程已获得的资源，在末使用完之前，不能强行剥夺。
3. 占有且等待：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
4. 循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系。

参考 Copy Chapter

• [sync.RWMutex]https://medium.com/golangspec/sync-rwmutex-ca6c6c3208a0

Discuss 2019 03 26 Gopsutil (`content/discuss/2019-03-26-gopsutil.md`) Copy Section

title: 2019-03-26 微信群讨论 date: 2019-03-26T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群
时间：未知

背景 Copy Chapter

先前由于公司这边要做一些基础指标的监控上报，因此之前在夜读群里和大家聊了下。经推荐最后使用了第三方库 gopsutil

今天我把之前查的资料重新翻了出来，大家有兴趣的可以看看。以备不时之需及学习一下

例子 Copy Chapter

package main

import (
	"time"
	"log"

	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/disk"
	"github.com/shirou/gopsutil/host"
	"github.com/shirou/gopsutil/load"
	"github.com/shirou/gopsutil/mem"
)

type StatusServer struct {
	Percent  StatusPercent
	CPU      []CPUInfo
	Mem      MemInfo
	Swap     SwapInfo
	Load     *load.AvgStat
	BootTime uint64
	Uptime   uint64
}
type StatusPercent struct {
	CPU  float64
	Disk float64
	Mem  float64
	Swap float64
}

type CPUInfo struct {
	ModelName string
	Cores     int32
}

type MemInfo struct {
	Total     uint64
	Used      uint64
	Available uint64
}

type SwapInfo struct {
	Total     uint64
	Used      uint64
	Available uint64
}

func main() {
	v, _ := mem.VirtualMemory()
	s, _ := mem.SwapMemory()
	c, _ := cpu.Info()
	cc, _ := cpu.Percent(time.Second, false)
	d, _ := disk.Usage("/")
	n, _ := host.Info()
	l, _ := load.Avg()
	ss := new(StatusServer)
	ss.Load = l
	ss.Uptime = n.Uptime
	ss.BootTime = n.BootTime
	ss.Percent.Mem = v.UsedPercent
	ss.Percent.CPU = cc[0]
	ss.Percent.Swap = s.UsedPercent
	ss.Percent.Disk = d.UsedPercent
	ss.CPU = make([]CPUInfo, len(c))
	for i, ci := range c {
		ss.CPU[i].ModelName = ci.ModelName
		ss.CPU[i].Cores = ci.Cores
	}
	ss.Mem.Total = v.Total
	ss.Mem.Available = v.Available
	ss.Mem.Used = v.Used
	ss.Swap.Total = s.Total
	ss.Swap.Available = s.Free
	ss.Swap.Used = s.Used

	log.Printf("Server: %+v", ss)
}

输出结果 Copy Chapter

2019/03/26 20:59:33 Server: &{
Percent:{CPU:46.38403990024938 Disk:77.4866172890781 Mem:67.66278743743896 Swap:95.16252790178571} 
CPU:[{ModelName:Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz Cores:2}] 
Mem:{Total:17179869184 Used:11624378368 Available:5555490816} 
Swap:{Total:7516192768 Used:7152599040 Available:363593728} 
Load:{"load1":4.28,"load5":3.37,"load15":3.21} 
BootTime:1550416891 
Uptime:3188282
}

Discuss 2019 04 10 Remove Local Branch In Merged Master (`content/discuss/2019-04-10-remove-local-branch-in-merged-master.md`) Copy Section

title: 2019-04-10 date: 2019-04-10T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

本地开发分支已经 merge 到 master 后，如何快捷的删除本地开发分支？ Copy Chapter

#!/bin/bash

function git_branch_cleanup() {
    for branch in `git branch --format='%(refname:short)'|grep -v '\*\|master'` ; do
        git checkout $branch
        check_results=`git fetch origin master && git rebase origin/master`
        result=$(echo $check_results | grep "up to date.")
        if [ "$result" == "" ];then
            echo "不包含 up to date. $check_results !\n"
        fi
    done
    git checkout master
    git branch --merged | grep -v '\*\|master' | xargs -n 1 git branch -d
}

git_branch_cleanup

你可以将以上代码创建到 /usr/local/bin/gcup，这样你就可以在项目中使用 gcup 命令了。

注意：gcup 需要权限：chmod +x gcup
如果之前没有清理无用分支，可能会有大量冲突需要处理。

其他办法：
我们也可以遍历本地所有分支，然后排除一些白名单的分支，然后再把其他的全部删掉。

git branch -d xxx 能删掉的就都删掉了，如果你确定 xxx 分支没有用了，你也可以强制删除 git branch -D xxx

更简洁的代码：git branch -d $(git branch -vv | grep ': gone\]' | awk '{print $1}')

Discuss 2019 05 15 Jaeger (`content/discuss/2019-05-15-jaeger.md`) Copy Section

title: 2019-05-15 date: 2019-05-15T00:00:00+08:00 Copy Chapter

来源：『Go 夜读』微信群

Q: jaeger好像是由入口服务决策这条trace是否需要采样上报的？所有下游的服务都会根据入口服务的采样标记决定是否将数据上报给agent，这样的话有个问题：
如果我的后端服务架构中，入口服务的请求量特别大，但是最下游的两三个服务请求量相对下（相差100倍以上），那如何妥善地设置采样比例？

比例小的话，下游服务的上报量可能会很少，统计分析的时候准确度不够；
比例大的话，入口服务的上报量又会太大

A: 不太明白：入口和最下游服务不是一起访问？

Q: 不是的，你可以把我们后台看作类似于漏斗形架构，数据每经过一个服务就会做判断，可能需要继续访问下游服务，也可能不需要、直接返回，所以越往下游的服务接受的请求量越小;
每个请求到底会经过哪些服务，是不固定的
依赖于每一层服务的判断结果;

A: 没想到办法[悠闲]

Q: 暂时想到的办法是，每台机的agent单独采样，根据单机请求量来调整上报数据, 这样可以确保每台机器的上报数据量均衡,但是es里最终存储的不是完整trace，完整trace需要单独回访数据

A: agent单独采样：是指使用远程采集策略？

Q: 不是远程策略，远程策略，归根到底也是入口服务做采样决策的，这里需要的是agent来决策采样，不过这样就意味着客户端到agent的数据是全量的，udp传输开销应该会很大，又需要改造为共享内存传输之类的。

A1: 那采样就进程内概率随机采，每台机的agent汇总，agent再做一些可动态调整的limiter呢

A: 不太清楚你的具体实现，但全量上报再由agent决策，好像也解决不了下游服务只有很小访问的问题吧？

Q: 下游服务访问量小，所以下游服务的机器agent就可以根据情况调整采样比例增加数据上报量

A: 意思是不需要看到和入口服务在同一条链路上？
Q: 是的，前面说的，这样的做法就是es存储的span不一定能拼成完整的trace;

Q: 需求上来讲，更需要的是全局视图, 统计整体链路的请求响应情况
需要某个具体case的时候再去回放，带有debug标志的trace的所有span都会上报，可以形成完整链路

A: 单独对你的下游服务设定不同的采集策略不会好点？

Q: 问题不是在于，jaeger是从入口服务进行采样决策的吗

Q: Jaeger libraries implement consistent upfront (or head-based) sampling.

or example, assume we have a simple call graph where service A calls service B, and B calls service C: A -> B -> C. When service A receives a request that contains no tracing information, Jaeger tracer will start a new trace, assign it a random trace ID, and make a sampling decision based on the currently installed sampling strategy. The sampling decision will be propagated with the requests to B and to C, so those services will not be making the sampling decision again but instead will respect the decision made by the top service A.

A: 如果你们能接受不在一条链路上,可以进行不同设定，例如入口使用随机采集策略，几率是（1/1000）,那下游服务就（1/100）

Q: “so those services will not be making the sampling decision again but instead will respect the decision made by the top service A”
jaeger下游服务不做采样决策了