Golang - slice 内部实现原理解析

最新推荐文章于 2024-05-29 11:47:44 发布

未来谁可知

最新推荐文章于 2024-05-29 11:47:44 发布

阅读量595

点赞数

文章标签： golang

本文链接：https://blog.csdn.net/jiohfgj/article/details/130529667

版权

Golang - slice 内部实现原理解析

一.Go中的数组和slice的关系

1.数组

在几乎所有的计算机语言中，数组的实现都是一段连续的内存空间，Go语言数组的实现也是如此，但是Go语言中的数组和C语言中数组还是有所不同的

C语言数组变量是指向数组第一个元素的指针
Go语言的数组是一个值，一个数组变量就代表整个数组，意味着Go语言的数组在传递的时候，传递是是原数组的拷贝！

这也就意味着数组在传递的时候，对大数组来说，内存代价会非常大，影响性能，传递数组指针可以解决这个问题，但是数组指针也有一个弊端：

原数组的指针指向改变了，那函数里面的指针指向也会跟着改变，某些情况下，可能会产生意想不到的bug

slice的出现，便是为了解决这个问题

2.slice

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dQzZaZgn-1683360323739)(https://gitee.com/cqfbest/md/raw/master/img2//1301290-20220114172752683-1165682702.png)]

先来看一张图,上图中，ptr就是指向底层数组的指针，len是指slice的长度，cap是指slice的容量

slice本身并不是动态数组或者数组指针，它的内部实现是通过指针引用底层数组，设置相关的属性，将数据的读写操作限定在指定的区域内
slice本身是一个只读读写，你修改的是底层数组，而不是slice本身，其工作机制类似于数组指针的一种封装
slice是对数组中一个连续片段的引用，所以slice是一个引用类型

当然从宏观和使用上来说，你可以将slice当做一个长度可变的数组，类似C++的Vector。

二.slice的初始化方式

方式1：字面量

    s = s[2:4]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZRTLnKlD-1683360323740)(https://gitee.com/cqfbest/md/raw/master/img2//1301290-20220114172829533-471833808.png)]

指针指向s[2]，容量是3，长度是2

需要注意的是，尽量不要采用字面量这种方式初始化slice，除非情况特殊，因为一个字面量数组可以初始化很多个slice，修改一个slice，会影响另一个slice的值，因为引用的都是同一个底层数组

比如下图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DpEW11hp-1683360323740)(https://gitee.com/cqfbest/md/raw/master/img2//1301290-20220114172858248-225632968.png)]

sliceA和sliceB都是同一个底层数组，并且有重叠的部分！Array[2],30

方式2：make

    s := make([]byte, 5)

最为安全的slice初始化方式，推荐使用，除非业务特殊你实在想让你的slice共用同一个底层数组，再补充一个图，来说明slice长度和容量的区别

长度4，代表此时4个元素，容量6，代表总共可以装6个元素，还有两个位置空闲

三.slice的扩容规则

slice可以理解为动态数组，既然是动态数组，那必然需要进行扩容，slice扩容遵循以下规则：

slice容量小于1024个元素，则扩容后容量直接翻倍，
slice容量不小于1024个元素，则每次增加原来容量是四分之一
如果扩容后，还是比底层数组的容量小，那么slice的指针还是指向原来的底层数组。
如果扩容后，超过了底层数组的容量，那么会开辟一块新内存，并将原来的值拷贝过来，这种情况，slice的任何操作都不会影响原底层数组

四. slice的拷贝

1.浅拷贝情况

浅拷贝，拷贝的是地址，只是复制指向对象的指针
slice是引用类型数据，默认引用类型数据，全部都是浅拷贝，slice，Map等

    slice2 := slice1

slice1和slice2指向的都是同一个底层数组，任何一个数组元素被改变，都可能会影响两个slice
在slice触发扩容操作前，slice1和slice2指向的都是相同数组，但在触发扩容操作后，二者指向的就不一定是相同的底层数组了，具体可参考上诉slice的扩容规则

2. 深拷贝情况

深拷贝，拷贝的是数据本身，会创建一个新对象

    copy(slice2, slice1)

新对象和原对象不共享内存，在新建对象的内存中开辟一个新的内存地址，新对象的值修改不会影响原对象值，既然内存地址不同，释放内存地址时，可以分别释放

五. slice内存泄露情况

当slice的底层数组很大，但slice所取元素数量很小时，底层数组占据的大部分空间都是被浪费的

比如b数组很大，slice a只引用了b很小的一部分，只要slice a还在，b数组就永远不会被回收，就是造成了内存泄露！

var a []int

func test(b []int) {
    a = b[:1] // 和b共用一个底层数组
    return
}

解决方法：

不再引用b数组，将需要的数据复制到一个新的slice中，这样新slice的底层数组，就和b数组无任何关系了

var a []int

func test(b []int) {
    a = make([]int, 1)
    copy(a, b[:0])
    return
}

六. slice 非并发安全

slice不是并发安全的，要并发安全，有两种方法:

加锁
channle

1.加锁

适合于对性能要求不高的场景，毕竟锁的粒度太大，这种方式属于通过共享内存来实现通信

func TestSliceConcurrencySafeByMutex(t *testing.T) {
    var lock sync.Mutex //互斥锁
    a := make([]int, 0)
    var wg sync.WaitGroup
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            lock.Lock()
            defer lock.Unlock()
            a = append(a, i)
        }(i)
    }
    wg.Wait()
    t.Log(len(a)) 
    // equal 10000
}

2.channle

适合于对性能要求大的场景，channle就是专用于goroutine间通信的，这种方式属于通过通信来实现共享内存，而Go的箴言便是：尽量通过通信来实现内存共享，而不是通过共享内存来实现通信，推荐此方法！

func TestSliceConcurrencySafeByChanel(t *testing.T) {
    buffer := make(chan int)
    a := make([]int, 0)
    // 消费者
    go func() {
        for v := range buffer {
            a = append(a, v)
        }
    }()
    // 生产者
    var wg sync.WaitGroup
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            buffer <- i
        }(i)
    }
    wg.Wait()
    t.Log(len(a)) 
    // equal 10000
}