记录一下日常中遇到的几个坑，加深一下印象。
#### 1、for range
这个是比较常见的问题了，我自己也整理一下：
```go
func main() {
l := []int{1,2,3}
fmt.Printf("%p \n", &l)
for _, v := range l {
fmt.Printf("%p : %d \n", &v,v)
}
}
```
输出结果
```json
0xc000092080
0xc00018a008 : 1
0xc00018a008 : 2
0xc00018a008 : 3
```
这边基本可以看出来了，v是一个临时分配出来的的内存，赋值为当前遍历的值。因此就可能会导致两个问题
- 对其本身没有操作
- 引用的是同一个变量地址
```go
func main() {
l := []int{1, 2, 3}
for _, v := range l {
v+=1
}
fmt.Println(l)
}
//[1 2 3]
```
```go
func main() {
m := make(map[string]*student)
stus := []student{
{Name: "a"},
{Name: "b"},
{Name: "c"},
}
for _, stu := range stus {
m[stu.Name] = &stu
}
fmt.Println(m)
}
//map[a:0xc000012060 b:0xc000012060 c:0xc000012060]
```
如果怕用错的话建议使用index，不要用value：
```go
for i, _ := range list {
list[i]//TODO
}
```
#### 2、defer与闭包
先来看一下两组代码和答案：
**未使用闭包**
```go
func main() {
for i := 0; i < 5; i++ {
defer fmt.Printf("%d %p ",i,&i)
}
}
//4 0xc00009a008 3 0xc00009a008 2 0xc00009a008 1 0xc00009a008 0 0xc00009a008
```
**使用闭包**
```go
func main() {
for i := 0; i < 5; i++ {
defer func() {
fmt.Printf("%d %p ", i, &i)
}()
}
}
//5 0xc000096018 5 0xc000096018 5 0xc000096018 5 0xc000096018 5 0xc000096018
```
`defer` 是一个延时调用关键字，会在当前函数执行结束前才被执行，后面的函数先会被编译，到了快结束前才会被输出，而不是结束前再进行编译。下面写了一些代码便于理解：
```go
func main() {
fmt.Println(time.Now().Second())
defer fmt.Println(time.Now().Second())
time.Sleep(time.Second)
}
//19
//19
func main() {
fmt.Println(time.Now().Second())
defer func() {
fmt.Println(time.Now().Second())
}()
time.Sleep(time.Second)
}
//22
//23
```
从上面代码可以看出，defer是及时编译的，因此在没有闭包的情况下，时间是相同的，但是在加了闭包之后，遇到defer之后会对匿名函数进行编译（不会进行函数内的操作），然后打入一个栈里，到了最后才会执行函数内的操作，所以输出不同。根据这个代码再看一下上面的问题。第一个没有闭包会直接对i进行取值放入栈里面，最后输出，因此可以得到想要的结果。但是当有了闭包之后，函数体里的方法不会立即执行，这个i所表现的只是一个内存地址，在最后输出时都指向了同一个地址，因此它的值是相同的。
了解原因之后，解决方法也就很简单，既然原因是因为传入参数的地址相同了，那使它不同就行了：
```go
func main() {
for i := 0; i < 5; i++ {
//j:=i
defer func(j int) {
fmt.Printf("%d %p ", j, &j)
}(i)
}
}
//4 0xc000018330 3 0xc000018340 2 0xc000018350 1 0xc000018360 0 0xc000018370
```
这两种写法一样，都是将当前的值赋值给一个新的对象（相当于指向了新的地址），不过给闭包函数加参数会显得更加优雅一点。
#### 3、map内存溢出
这个问题在个人开发时几乎不会考虑，当服务数据量很大时才需要注意一下，上一遍文章也专门写了一下关于go里面的map的相关内容，具体问题是由于map的删除并不是真正的释放内存空间，比如一个map里面有1w个k-v，然后其中5k个不需要被删除了，接着往里面继续添加1k个键值对，此时map所占的内存大小很有可能仍为11k个键值对的大小，这将会导致所占用的内存会越来越大，造成内存溢出。方法就是将原本map中有用的值重新加入到新的map中：
```go
oldMap := make(map[int]int, 10000)
newMap := make(map[int]int, len(oldMap))
for k, v := range oldMap {
newMap[k] = v
}
oldMap = newMap
```
方法是有了，但是到底该怎么用呢？下面说一下我个人的看法：
1. map是线程不安全，如何保证在数据迁移的时候保证线性安全，加锁，读写锁sync.RWMutex
2. 什么时候迁移，set的时候是不合适的，固定的时间间隔？不太好。因为是删除导致的内存问题，那么就在delete中进行迁移，添加计数记录已删除个数，比如当删除数目达到10000或者达到某个比例时进行
#### 4、协程泄漏
协程泄漏是我同事开发时遇到的一个问题，这边我也记录一下。
*什么是协程泄漏*，大体的意思是主程序已经跑完了，但是主程序中开的go协程没有结束。如何知道协程是否发生了泄漏，最简单的方法是runtime.NumGoroutine()得到结果是否与你的期望值一样，如果大了就是发生了泄漏。
*哪些问题会导致协程泄漏?*
1、死循环
```go
func main() {
defer func() {
time.Sleep(time.Second)
fmt.Println("the number of goroutines: ", runtime.NumGoroutine())
}()
go func() {
select {
}
}()
}
//the number of goroutines: 2
```
2、锁（chan的就是锁+队列的实现）
```go
func queryAll(n int) int {
ch := make(chan int)
for i := 0; i < n; i++ {
go func(i int) {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
ch <- i
}(i)
}
s := <-ch
return s
}
func main() {
queryAll(3)
time.Sleep(time.Second) //查看一段时间后的协程数
fmt.Printf("the number of goroutines: %d", runtime.NumGoroutine())
}
//the number of goroutines: 3
```
死循环好理解，conrountinue一直在运行，没有退出。
对于通道举例说明：海陆空三路一起送一份邮件，只需要第一个送到的，main主协程为收件人，收件人开着门在门口等着收邮件，在收到第一个人的邮件时，门没关就直接进屋研究去了（主协程结束），后面两位过一会也到了，但是发现门没关，认为家里有人就一直在等着（协程堵塞，资源泄漏）。那么这时候该怎么办？如何close了这个门，那后面两个人到了发现门是关着的，这么紧急的邮件居然关门了（并不知道有人已经送到了）就会认为可能出问题了，panic。正确的解决方案可以有下面几个：
1. 放一个信箱，收到的邮件都放里面，只取第一个；
```go
func queryAll(n int) int {
ch := make(chan int, n)
for i := 0; i < n; i++ {
go func(i int) {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
ch <- i
}(i)
}
s := <-ch
return s
}
func main() {
queryAll(3)
time.Sleep(time.Second)
fmt.Printf("the number of goroutines: %d", runtime.NumGoroutine())
}
//the number of goroutines: 1
```
2. 知道总共有几份邮件，收件人在门口都等着全部收完（直接扔了就行）
```go
func queryAll(n int) int {
ch := make(chan int)
totla:=0
for i := 0; i < n; i++ {
go func(i int) {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
ch <- i
}(i)
}
s := <-ch
for range ch{
totla++
if totla==n-1{
close(ch)
}
}
return s
}
func main() {
queryAll(3)
time.Sleep(time.Second)
fmt.Printf("the number of goroutines: %d", runtime.NumGoroutine())
}
//the number of goroutines: 1
```
3. 还有一种想法是收到第一份邮件后直接通知其他没有必要再送了，不过这个感觉目前实现不了（协程里需要不断请求是否有人成功了），有大佬可以帮忙不。
#### 5、http手动关闭
这个算是比较简单的错误了，不关闭的话会发生内存泄漏，具体原因没有了解，个人理解可以将response.body认为一个网络型的os file，和你读取本地文件效果一样，数据被写到缓存去了，不关闭的话将会占用资源。
```go
// An error is returned if there were too many redirects or if there
// was an HTTP protocol error. A non-2xx response doesn't cause an
// error. Any returned error will be of type *url.Error. The url.Error
// value's Timeout method will report true if request timed out or was
// canceled.
//
// When err is nil, resp always contains a non-nil resp.Body.
// Caller should close resp.Body when done reading from it.
//
// Get is a wrapper around DefaultClient.Get.
//
// To make a request with custom headers, use NewRequest and
// DefaultClient.Do.
func Get(url string) (resp *Response, err error) {
return DefaultClient.Get(url)
}
```
**Caller should close resp.Body when done reading from it.** 这一句话 go/src/net/http/client.go 里多次提到过了提过，注意一下就行
有疑问加站长微信联系（非本文作者））
