golang容易导致内存泄漏的6种情况汇总

 更新时间:2023年01月09日 09:44:01   作者:Yuan_sr  
内存泄漏是我们在生产环境中必须面临的问题,下面这篇文章主要给大家介绍了关于golang容易导致内存泄漏的6种情况,文中通过实例代码介绍的非常详细,需要的朋友可以参考下

脚本之家 / 编程助手:解决程序员“几乎”所有问题!
脚本之家官方知识库 → 点击立即使用

1. 定时器使用不当

1.1 time.After()的使用

默认的time.After()是会有内存泄露问题的,因为每次time.After(duration x)会产生NewTimer(),在duration x到期之前,新创建的timer不会被GC,到期之后才会GC。

随着时间推移,尤其是duration x很大的话,会产生内存泄露的问题,应特别注意

1
2
3
4
5
6
7
8
for true {
    select {
    case <-time.After(time.Minute * 3):
    // do something
  default:
        time.Sleep(time.Duration(1) * time.Second)
    }
}

为了保险起见,使用NewTimer()或者NewTicker()代替的方式主动释放资源,两者的区别请自行查阅或看我往期文章https://blog.csdn.net/weixin_38299404/article/details/119352884

1
2
3
4
5
6
7
8
9
10
timer := time.NewTicker(time.Duration(2) * time.Second)
defer timer.Stop()
for true {
    select {
    case <-timer.C:
        // do something
    default:
        time.Sleep(time.Duration(1) * time.Second)
    }
}

1.2 time.NewTicker资源未及时释放

在使用time.NewTicker时需要手动调用Stop()方法释放资源,否则将会造成永久性的内存泄漏

1
2
3
4
5
6
7
8
9
10
timer := time.NewTicker(time.Duration(2) * time.Second)
// defer timer.Stop()
for true {
    select {
    case <-timer.C:
        // do something
    default:
        time.Sleep(time.Duration(1) * time.Second)
    }
}

2. select阻塞

使用select时如果有case没有覆盖完全的情况且没有default分支进行处理,最终会导致内存泄漏

2.1 导致goroutine阻塞的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    ch3 := make(chan int)
    go Getdata("https://www.baidu.com",ch1)
    go Getdata("https://www.baidu.com",ch2)
    go Getdata("https://www.baidu.com",ch3)
    select{
        case v:=<- ch1:
            fmt.Println(v)
        case v:=<- ch2:
            fmt.Println(v)
    }
}

上述这种情况会阻塞在ch3的消费处导致内存泄漏

2.2 循环空转导致CPU暴涨

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func main() {
    fmt.Println("main start")
    msgList := make(chan int, 100)
    go func() {
        for {
            select {
            case <-msgList:
            default:
  
            }
        }
    }()
     
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt, os.Kill)
    s := <-c
     
    fmt.Println("main exit.get signal:", s)
}

上述for循环条件一旦命中default则会出现循环空转的情况,并最终导致CPU暴涨

3. channel阻塞

channel阻塞主要分为写阻塞和读阻塞两种情况

空channel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func channelTest() {
    //声明未初始化的channel读写都会阻塞
    var c chan int
    //向channel中写数据
    go func() {
        c <- 1
        fmt.Println("g1 send succeed")
        time.Sleep(1 * time.Second)
    }()
    //从channel中读数据
    go func() {
        <-c
        fmt.Println("g2 receive succeed")
        time.Sleep(1 * time.Second)
    }()
    time.Sleep(10 * time.Second)
}

写阻塞

无缓冲channel的阻塞通常是写操作因为没有读而阻塞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func channelTest() {
    var c = make(chan int)
    //10个协程向channel中写数据
    for i := 0; i < 10; i++ {
        go func() {
            <- c
            fmt.Println("g1 receive succeed")
            time.Sleep(1 * time.Second)
        }()
    }
    //1个协程丛channel读数据
    go func() {
        c <- 1
        fmt.Println("g2 send succeed")
        time.Sleep(1 * time.Second)
    }()
    //会有写的9个协程阻塞得不到释放
    time.Sleep(10 * time.Second)
}

有缓冲的channel因为缓冲区满了,写操作阻塞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func channelTest() {
    var c = make(chan int, 8)
    //10个协程向channel中写数据
    for i := 0; i < 10; i++ {
        go func() {
            <- c
            fmt.Println("g1 receive succeed")
            time.Sleep(1 * time.Second)
        }()
    }
    //1个协程丛channel读数据
    go func() {
        c <- 1
        fmt.Println("g2 send succeed")
        time.Sleep(1 * time.Second)
    }()
    //会有写的几个协程阻塞写不进去
    time.Sleep(10 * time.Second)
}

读阻塞

期待从channel读数据,结果没有goroutine往进写数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func channelTest() {
   var c = make(chan int)
  //1个协程向channel中写数据
  go func() {
    <- c
    fmt.Println("g1 receive succeed")
    time.Sleep(1 * time.Second)
  }()
  //10个协程丛channel读数据
  for i := 0; i < 10; i++ {
    go func() {
        c <- 1
        fmt.Println("g2 send succeed")
        time.Sleep(1 * time.Second)
    }()
  }
  //会有读的9个协程阻塞得不到释放
  time.Sleep(10 * time.Second)
}

4. goroutine导致的内存泄漏

4.1 申请过多的goroutine

例如在for循环中申请过多的goroutine来不及释放导致内存泄漏

4.2 goroutine阻塞

4.2.1 I/O问题

I/O连接未设置超时时间,导致goroutine一直在等待,代码会一直阻塞。

4.2.2 互斥锁未释放

goroutine无法获取到锁资源,导致goroutine阻塞

1
2
3
4
5
6
7
8
9
10
11
12
13
//协程拿到锁未释放,其他协程获取锁会阻塞
func mutexTest() {
    mutex := sync.Mutex{}
    for i := 0; i < 10; i++ {
        go func() {
            mutex.Lock()
            fmt.Printf("%d goroutine get mutex", i)
                //模拟实际开发中的操作耗时
            time.Sleep(100 * time.Millisecond)
        }()
    }
    time.Sleep(10 * time.Second)
}

4.2.3 死锁

当程序死锁时其他goroutine也会阻塞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func mutexTest() {
    m1, m2 := sync.Mutex{}, sync.RWMutex{}
    //g1得到锁1去获取锁2
    go func() {
        m1.Lock()
        fmt.Println("g1 get m1")
        time.Sleep(1 * time.Second)
        m2.Lock()
        fmt.Println("g1 get m2")
    }()
    //g2得到锁2去获取锁1
    go func() {
        m2.Lock()
        fmt.Println("g2 get m2")
        time.Sleep(1 * time.Second)
        m1.Lock()
        fmt.Println("g2 get m1")
    }()
    //其余协程获取锁都会失败
    go func() {
        m1.Lock()
        fmt.Println("g3 get m1")
    }()
    time.Sleep(10 * time.Second)
}

4.2.4 waitgroup使用不当

waitgroup的Add、Done和wait数量不匹配会导致wait一直在等待

5. slice 引起的内存泄漏

当两个slice 共享地址,其中一个为全局变量,另一个也无法被GC;

append slice 后一直使用,没有进行清理。

1
2
3
4
5
6
var a []int
  
func test(b []int) {
        a = b[:3]
        return
}

6. 数组的值传递

由于数组时Golang的基本数据类型,每个数组占用不通的内存空间,生命周期互不干扰,很难出现内存泄漏的情况,但是数组作为形参传输时,遵循的时值拷贝,如果函数被多个goroutine调用且数组过大时,则会导致内存使用激增。

1
2
3
4
5
6
7
8
//统计nums中target出现的次数
func countTarget(nums [1000000]int, target int) int {
    num := 0
    for i := 0; i < len(nums) && nums[i] == target; i++ {
        num++
    }
    return num
}

因此对于大数组放在形参场景下通常使用切片或者指针进行传递,避免短时间的内存使用激增。

总结

到此这篇关于golang容易导致内存泄漏的6种情况的文章就介绍到这了,更多相关golang内存泄漏内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

蓄力AI

微信公众号搜索 “ 脚本之家 ” ,选择关注

程序猿的那些事、送书等活动等着你

原文链接:https://blog.csdn.net/weixin_38299404/article/details/126805554

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符,请将相关资料发送至 reterry123@163.com 进行投诉反馈,一经查实,立即处理!

相关文章

  • Go语言命令行参数及cobra使用方法

    Go语言命令行参数及cobra使用方法

    Cobra是关于golang的一个命令行解析库,用它能够快速创建功能强大的 cli应用程序和命令行工具,本文主要介绍了Go语言命令行参数及cobra使用方法,感兴趣的可以了解一下
    2024-01-01
  • Golang gin跨域解决方案示例

    Golang gin跨域解决方案示例

    这篇文章主要为大家介绍了Golang gin跨域解决方案,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2022-04-04
  • 关于golang中死锁的思考与学习

    关于golang中死锁的思考与学习

    本文主要介绍了关于golang中死锁的思考与学习,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-03-03
  • 详解golang中Context超时控制与原理

    详解golang中Context超时控制与原理

    Context本身的含义是上下文,我们可以理解为它内部携带了超时信息、退出信号,以及其他一些上下文相关的值,本文给大家详细介绍了golang中Context超时控制与原理,文中有相关的代码示例供大家参考,需要的朋友可以参考下
    2024-01-01
  • Go语言高效I/O并发处理双缓冲和Exchanger模式实例探索

    Go语言高效I/O并发处理双缓冲和Exchanger模式实例探索

    这篇文章主要介绍了Go语言高效I/O并发处理双缓冲和Exchanger模式实例探索,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2024-01-01
  • 浅谈golang 的高效编码细节

    浅谈golang 的高效编码细节

    本文主要介绍了golang 的高效编码细节,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-10-10
  • docker中部署golang项目的步骤详解

    docker中部署golang项目的步骤详解

    这篇文章主要给大家介绍了关于在docker中部署golang项目的步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
    2017-11-11
  • 一文搞懂Go语言标准库strconv

    一文搞懂Go语言标准库strconv

    strconv包实现了基本数据类型和其字符串表示的相互转换,本文主要介绍Go语言标准库strconv,想要学习strconv标准库的可以了解一下
    2023-04-04
  • 深入理解Golang make和new的区别及实现原理

    深入理解Golang make和new的区别及实现原理

    在Go语言中,有两个比较雷同的内置函数,分别是new和make方法,二者都可以用来分配内存,那他们有什么区别呢?下面我们就从底层来分析一下二者的不同。感兴趣的小伙伴们可以参考借鉴,希望对大家能有所帮助
    2022-10-10
  • Go语言扩展原语之Semaphore的用法详解

    Go语言扩展原语之Semaphore的用法详解

    Go语言的扩展包中提供了带权重的信号量 semaphore.Weighted,让我们可以按照不同的权重管理资源的访问,下面小编就来和大家聊聊它们的具体用法吧
    2023-07-07

最新评论