1. 修改 .gitmodules 文件中对应模块的url属性;
2. 使用 git submodule sync 命令，将新的URL更新到文件.git/config；
3. 再使用命令初始化子模块：git submodule init
4. 最后使用命令更新子模块：git submodule update

对于Windows WSL的安装和对应镜像安装此片不做具体介绍，本篇文章只介绍Goland配置
首先Goland 打开相应代码项目后

通过菜单 File->Settings
打开Settings设置

Run Targets配置

打开Run Targets配置

然后添加 WSL

选择自己本地对应的WSL

根据自己WSL镜像中的go配置，选择对应的目录

然后修改编辑当前编译项目配置，选择前面设置的Targets

最后保存即可在WSL编译项目了

介绍

经常会看到以下了代码：

package main

import (
    "fmt"
    "time"
)

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

主线程为了等待goroutine都运行完毕，不得不在程序的末尾使用time.Sleep() 来睡眠一段时间，等待其他线程充分运行。对于简单的代码，100个for循环可以在1秒之内运行完毕，time.Sleep() 也可以达到想要的效果。

但是对于实际生活的大多数场景来说，1秒是不够的，并且大部分时候我们都无法预知for循环内代码运行时间的长短。这时候就不能使用time.Sleep() 来完成等待操作了。

可以考虑使用管道来完成上述操作：

func main() {
    c := make(chan bool, 100)
    for i := 0; i < 100; i++ {
        go func(i int) {
            fmt.Println(i)
            c <- true
        }(i)
    }

    for i := 0; i < 100; i++ {
        <-c
    }
}

首先可以肯定的是使用管道是能达到我们的目的的，而且不但能达到目的，还能十分完美的达到目的。

但是管道在这里显得有些大材小用，因为它被设计出来不仅仅只是在这里用作简单的同步处理，在这里使用管道实际上是不合适的。而且假设我们有一万、十万甚至更多的for循环，也要申请同样数量大小的管道出来，对内存也是不小的开销。

对于这种情况，go语言中有一个其他的工具sync.WaitGroup 能更加方便的帮助我们达到这个目的。

WaitGroup 对象内部有一个计数器，最初从0开始，它有三个方法：Add(), Done(), Wait() 用来控制计数器的数量。Add(n) 把计数器设置为n ，Done() 每次把计数器-1 ，wait() 会阻塞代码的运行，直到计数器地值减为0。

使用WaitGroup 将上述代码可以修改为：

func main() {
    wg := sync.WaitGroup{}
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func(i int) {
            fmt.Println(i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

这里首先把wg 计数设置为100， 每个for循环运行完毕都把计数器减一，主函数中使用Wait() 一直阻塞，直到wg为零——也就是所有的100个for循环都运行完毕。相对于使用管道来说，WaitGroup 轻巧了许多。

注意事项

1. 计数器不能为负值

我们不能使用Add() 给wg 设置一个负值，否则代码将会报错：

panic: sync: negative WaitGroup counter

goroutine 1 [running]:
sync.(*WaitGroup).Add(0xc042008230, 0xffffffffffffff9c)
    D:/Go/src/sync/waitgroup.go:75 +0x1d0
main.main()
    D:/code/go/src/test-src/2-Package/sync/waitgroup/main.go:10 +0x54

同样使用Done() 也要特别注意不要把计数器设置成负数了。

2. WaitGroup对象不是一个引用类型

WaitGroup对象不是一个引用类型，在通过函数传值的时候需要使用地址：

func main() {
    wg := sync.WaitGroup{}
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go f(i, &wg)
    }
    wg.Wait()
}

// 一定要通过指针传值，不然进程会进入死锁状态
func f(i int, wg *sync.WaitGroup) { 
    fmt.Println(i)
    wg.Done()
}

转载自：https://blog.csdn.net/u013474436/article/details/88749749

https://github.com/Blurooo/go-monitor
https://www.jianshu.com/p/c97ffca5a31d
https://cloud.tencent.com/document/product/1416/56033
https://github.com/Blurooo/go-monitor
https://github.com/ksred/go-monitor
https://github.com/netbound/e7mon
https://golangrepo.com/repo/netbound-e7mon-go-cryptography
https://www.btcsearch.com/t/966846
https://github.com/ethereum/go-ethereum/wiki/Metrics-and-Monitoring
https://medium.com/coinmonks/how-to-build-ethereum-dashboard-and-to-monitor-your-ethereum-network-status-9f1941beac08
https://github.com/WeBankPartners/open-monitor
https://consensys.net/docs/goquorum/en/latest/configure-and-manage/monitor/metrics/
https://github.com/ethereum/go-ethereum/issues/24178

在go test命令后面添加 -cover参数开启测试覆盖率统计，其结果如下：

ok models 0.012s coverage: 71.4% of statements in models

-coverpkg 标记来指定要被统计的代码包之后，未被指定的代码则肯定不会被统计，即使是被直接测试的那个代码包。go test -coverpkg=./... pkg2可以跑pkg2下的所有单元测试及pkg2所用到的其他包的覆盖率情况。
但是由于go不支持go test -coverpkg=./... ./...如果我们有多个pkg，则无法一次性统计出所有的测试覆盖率和跑完全部单元测试。所以需要挨个跑完单元测试然自己来合并覆盖率的结果：

src
├── pkg1
│   ├── pkg11
│   └── pkg12
└── pkg2
    ├── pkg21
    └── pkg22

go test -coverprofile=pkg1.cover.out -coverpkg=./... pkg1
go test -coverprofile=pkg1.cover.out -coverpkg=./... pkg2

-coverprofile用来指定统计测试覆盖率信息的输出路径，其内容如下：

mode: set
models/bot.go:32.40,46.18 12 1
models/bot.go:49.2,57.35 5 1
...

第一行是测试覆盖的mode，可取值为：set,count,atomic。剩下的行遵循以下的格式：
name.go:line.column,line.column numberOfStatements count
所以对每个pkg跑完单元测试后可以用以下的命令来合并：

echo "mode: set" > coverage.out && cat *.cover.out | grep -v mode: | sort -r | \
awk '{if($1 != last) {print $0;last=$1}}' >> coverage.out

然后用go自带的工具来将其输出为HTML：
go tool cover -html=coverage.out -o cover.html
把整个流程串起来写成脚本如下：

#!/bin/bash

set -e

profile="cover.out"
htmlfile="cover.html"
mergecover="merge_cover"
mode="set"

for package in $(go list ./...|grep -v src); do
    coverfile="$(echo $package | tr / -).cover"
    go test -covermode="$mode" -coverprofile="$coverfile" -coverpkg="$package" "$package"
done

# merge all profiles
grep -h -v "^mode:" *.cover | sort > $mergecover

# aggregate duplicated code-block data
echo "mode: $mode" > $profile
current=""
count=0
while read line; do
    block=$(echo $line | cut -d ' ' -f1-2)
    num=$(echo $line | cut -d ' ' -f3)
    if [ "$current" == "" ]; then
        current=$block
        count=$num
    elif [ "$block" == "$current" ]; then
        count=$(($count + $num))
    else
        echo $current $count >> $profile
        current=$block
        count=$num
    fi
done < $mergecover

if [ "$current" != "" ]; then
    echo $current $count >> $profile
fi

# save result
go tool cover -html=$profile -o $htmlfile
go tool cover -func=$profile

转载自：https://singlecool.com/2017/06/11/golang-test/