go语言中slice,map,channl底层原理

目录
  • 0. 前序
  • 1. slice
    • 1.1 slice的创建
    • 1.2 数据结构
    • 1.3 扩容机制
  • 2. map
    • 2.1 map创建
    • 2.2 数据结构
    • 2.3 扩容机制
  • 3. channl
    • 3.1 数据结构
    • 3.2 过程详解

0. 前序

slice,map,channl是我们Go语言中最最常用的几个数据结构,对于这些做到知根知底,对于我们建立知识体系以及优化代码都有着很重要的意义,所以本文,我们深入这三个数据结构的底层,剖析其设计思想。

1. slice

1.1 slice的创建

slice的创建主要有两种方式,第一种方式是直接创建

var sli []int
sli = make([]int, len, cap) // cap可以省略

//或者
sli := make([]int, len, cap) // cap可以省略

另一种方式是借助array创建:

arr := []int{1,2,3,4,5}
sli := arr[sta:end:cap] // :cap可以省略,以这种方式创建的sli,其cap为sta到arr的最后一位

1.2 数据结构

slice底层数据结构如下:

type {
    array unsafe.Pointer // 指针
    len int // 现有长度
    cap int // 容量
}

在Go语言中,所有的参数传递都是值传递,slice也是如此,不过由于其底层的指针,在其传递到另一个函数后,仍能对其地址对应位置的值做修改,然而,当发生扩容操作时,由于会重新分配地址,就会导致问题的发生,下面我们就来介绍slice的扩容机制。

1.3 扩容机制

在进行append()并且cap不够用的时候,会触发扩容操作(copy()操作不会触发扩容)。

容量的确定:

  • 如果期望容量大于当前容量的两倍就会使用期望容量;
  • 如果当前切片的长度小于 1024 就会将容量翻倍;
  • 如果当前切片的长度大于 1024 就会每次增加 25% 的容量,直到新容量大于期望容量;

上面所说的是一个容量的初步确定步骤,当数据类型size为1字节,8字节,或者2的倍数时,会根据内存大小进行向上取整,进行内存对齐,之后返回新的扩容大小。

内存对齐的一个重要原因是因为Go进行内存分配时是类似于伙伴系统的固定的内存块,对齐这个内存可以最大化的人利用分配到的空间。

2. map

2.1 map创建

m = make(map[int]int) // 需要注意 make(map)返回的是一个指针 

2.2 数据结构

type hmap {
    count int
    flags uint8 // map当前是否处于写入状态等
    B     uint8 // 2的B次幂表示当前map中桶的数量(buckets的长度)
    noverlow uint16 // map中溢出桶的数量,当溢出桶太多时,map会进行等量扩容
    hash0 uint32 //生成hash的随机数种子

    buckets unsafe.Pointer //当前map对应的桶的指针
    oldbuckets unsafe.Pointer // 扩容时的旧桶
    nevacuate uintptr //扩容时,用于标记当前旧桶中小于nevacute的数据都已经转移到了新桶

    extra *mapextra //存储map的溢出桶
}

Go中的map的数据都是存在bmap的数据结构中的,最多放8个kv对,溢出桶的设计与GC有关系,如果map为内联数据类型时,map数据结构里的指针就只有溢出桶了,这个时候就可以避免遍历map。

2.3 扩容机制

当我们插入一个k-v对时,需要确定他应该插入到bucket数组的哪一个槽中。bucket数组的长度为2^B,即2的次幂数,而2^B-1转换成二进制后一定是低位全1,高位全0的形式,因此在进行按位与操作后,一定能求得一个在[0,2^B-1]区间上的任意一个数,也就是数组中的下标位置,相较之下,能获得比取模更加优秀的执行效率。

涉及到扩容,每一次bucket数组都会变为现在的两倍,方便我们进行hash迁移。

map触发扩容的条件有两种:

  • 负载因子大于6.5时(负载因子 = 键数量 / bucket数量)
  • overflow的数量达到2^min(15,B)

等量扩容 所谓等量扩容,并不是扩大容量,而是bucket数量不变,重新做一遍类似增量扩容的搬迁动作,把松散的键值对重新排列一次,以使bucket的使用率更高,从而保证更快的存取速度。

3. channl

3.1 数据结构

type hchan struct {
    qcount   uint           // total data in the queue
    dataqsiz uint           // size of the circular queue
    buf      unsafe.Pointer // points to an array of dataqsiz elements
    elemsize uint16
    closed   uint32
    elemtype *_type // element type
    sendx    uint   // send index
    recvx    uint   // receive index
    recvq    waitq  // list of recv waiters
    sendq    waitq  // list of send waiters

    // lock protects all fields in hchan, as well as several
    // fields in sudogs blocked on this channel.
    //
    // Do not change another G's status while holding this lock
    // (in particular, do not ready a G), as this can deadlock
    // with stack shrinking.
    lock mutex
}

3.2 过程详解

channl的入队与出队操作都是都是加锁的,以此来保证并发安全。当队列满了再插入数据时,插入线程g会进入wait状态并且挂在sendq队列上,等取出元素时会将其唤醒,空队取元素同理。

到此这篇关于go语言中slice,map,channl底层原理的文章就介绍到这了,更多相关go slice,map,channl 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • go 判断两个 slice/struct/map 是否相等的实例

    可以通过 reflect.DeepEqual 比较两个 slice/struct/map 是否相等: package main import ( "fmt" "reflect" ) type A struct { s string } func main() { a1 := A{s: "abc"} a2 := A{s: "abc"} if reflect.DeepEqual(a1, a2) { fmt.Println(a1,

  • Go遍历struct,map,slice的实现

    遍历结构体 如何实现遍历结构体字段? 好吧,言归正传!举个例子: demo1: package main import ( "fmt" "reflect" ) type Student struct { name string age int } func main() { v := reflect.ValueOf(Student{"乔峰", 29}) count := v.NumField() for i := 0; i < count;

  • 理解Golang中的数组(array)、切片(slice)和map

    我比较喜欢先给出代码,然后得出结论 数组 复制代码 代码如下: package main import (     "fmt" ) func main() {     arr := [...]int{1, 2, 3}     //打印初始的指针     fmt.Printf("the pointer is : %p \n", &arr)     printPointer(arr) } func printPointer(any interface{}) {

  • Go语言中的Array、Slice、Map和Set使用详解

    Array(数组) 内部机制 在 Go 语言中数组是固定长度的数据类型,它包含相同类型的连续的元素,这些元素可以是内建类型,像数字和字符串,也可以是结构类型,元素可以通过唯一的索引值访问,从 0 开始. 数组是很有价值的数据结构,因为它的内存分配是连续的,内存连续意味着可是让它在 CPU 缓存中待更久,所以迭代数组和移动元素都会非常迅速. 数组声明和初始化 通过指定数据类型和元素个数(数组长度)来声明数组. 复制代码 代码如下: // 声明一个长度为5的整数数组 var array [5]int

  • GO中 分组声明与array, slice, map函数

    目录 iota 枚举 Go 程序设计的一些规则 数组 切片 map make.new 操作 前言: 在 Go 语言中,同时声明多个常量.变量,或者导入多个包时,可采用分组的方式进行声明. 例如下面的代码: import "fmt" import "os" const i = 100 const pi = 3.1415 const prefix = "Go_" var i int var pi float32 var prefix string1

  • go语言中slice,map,channl底层原理

    目录 0. 前序 1. slice 1.1 slice的创建 1.2 数据结构 1.3 扩容机制 2. map 2.1 map创建 2.2 数据结构 2.3 扩容机制 3. channl 3.1 数据结构 3.2 过程详解 0. 前序 slice,map,channl是我们Go语言中最最常用的几个数据结构,对于这些做到知根知底,对于我们建立知识体系以及优化代码都有着很重要的意义,所以本文,我们深入这三个数据结构的底层,剖析其设计思想. 1. slice 1.1 slice的创建 slice的创建

  • Go语言中slice作为参数传递时遇到的一些“坑”

    前言 相信看到这个题目,可能大家都觉得是一个老生常谈的月经topic了.一直以来其实把握一个"值传递"基本上就能理解各种情况了,不过最近遇到了更深一点的"小坑",与大家分享一下. 首先还是从最简单的说起,看下面代码: func main() { a := []int{7,8,9} fmt.Printf("len: %d cap:%d data:%+v\n", len(a), cap(a), a) ap(a) fmt.Printf("le

  • Go语言中slice的用法实例分析

    本文实例讲述了Go语言中slice的用法.分享给大家供大家参考.具体如下: slice 指向数组的值,并且同时包含了长度信息. []T 是一个元素类型为 T 的 slice. 复制代码 代码如下: package main import "fmt" func main() {  p := []int{2, 3, 5, 7, 11, 13}  fmt.Println("p ==", p)  for i := 0; i < len(p); i++ {   fmt.

  • Go语言中Slice常见陷阱与避免方法详解

    目录 前言 slice 作为函数 / 方法的参数进行传递的陷阱 slice 通过 make 函数初始化,后续操作不当所造成的陷阱 性能陷阱 内存泄露 扩容 前言 Go 语言提供了很多方便的数据类型,其中包括 slice.然而,由于 slice 的特殊性质,在使用过程中易犯一些错误,如果不注意,可能导致程序出现意外行为.本文将详细介绍 使用 slice 时易犯的一些错误,帮助读者更好的使用 Go 的 slice,避免犯错误. slice 作为函数 / 方法的参数进行传递的陷阱 slice 作为参数

  • 详解 Go 语言中 Map 类型和 Slice 类型的传递

    Map 类型 先看例子 m1: func main() { m := make(map[int]int) mdMap(m) fmt.Println(m) } func mdMap(m map[int]int) { m[1] = 100 m[2] = 200 } 结果是 map[2:200 1:100] 我们再修改如下 m2: func main() { var m map[int]int mdMap(m) fmt.Println(m) } func mdMap(m map[int]int) {

  • 详解Go语言中Goroutine退出机制的原理及使用

    目录 退出方式 进程/main函数退出 通过channel退出 通过context退出 通过Panic退出 等待自己退出 阻止goroutine退出的方法 通过sync.WaitGroup 通过channel 封装 总结 goroutine是Go语言提供的语言级别的轻量级线程,在我们需要使用并发时,我们只需要通过 go 关键字来开启 goroutine 即可.作为Go语言中的最大特色之一,goroutine在日常的工作学习中被大量使用着,但是对于它的调度处理,尤其是goroutine的退出时机和

  • 一文带你深入探究Go语言中的sync.Map

    目录 1. Map 的基本实现原理 2. sync.Map 的实现原理 2.1 sync.Map 的结构体定义 2.2 sync.Map 的读取实现 2.3 sync.Map 的写入实现 2.4 sync.Map 的删除实现 2.5 sync.Map 的遍历实现 在 Go 语言中,有一个非常实用的并发安全的 Map 实现:sync.Map,它是在 Go 1.9 版本中引入的.相比于标准库中的 map,它的最大特点就是可以在并发情况下安全地读写,而不需要加锁.在这篇博客中,我们将深入探讨 sync

  • 浅析R语言中map(映射)与reduce(规约)

    map(映射)与reduce(规约)操作在数据处理中非常常见,R语言的核心是向量化操作,自带的apply系列函数完成了数据框的向量化计算,而purrr包中的map与reduce系列函数很好的拓展了向量化计算,使R语言处理数据更加优雅流畅. purrr包是tidyverse系列中的包,开发者是大名鼎鼎的Hadley Wickham.purrr包中的函数很多,使用最多的是map与reduce系列函数. 安装包 install.packages('purrr') map map表示映射,可以在一个或多

  • Go语言中的Base64编码原理介绍以及使用

    目录 前言 Go Base64编码 什么是Base64编码 为什么需要Base64编码 Base64编码原理 编码步骤 位数不足情况 Base64解码原理 Base64标准编码变种 总结 前言 在网络中传递参数时,我们经常会对参数进行Base64编码,那么Go 语言中如何进行Base64编码呢?Base64编码的原理是怎样的呢?通过这篇文章一起来了解下吧! Go Base64编码 标准Base64编码 // 标准Base64编码     src := "hello world"   

随机推荐