由浅到深,入门Go语言Map实现原理

Golang map实践以及实现原理 Map实践以及实现原理实例 实例 阅读详情

Go源码版本1.13.8

前言

写博客的目的?

把自己学习知识进行一个总结。同时把一些可能困难、复杂难以理解的东西自我消化吸收后,简单化输出,降低他人的学习成本,提高他人的学习效率,主要为如下两点:

  • 自我学习的总结过程

  • 简化他人学习成本的结果

其次,或多或少存在自己学习过程中理解不到位或者错误的地方希望大家可能及时帮我纠正,感谢以及说一声抱歉。

为什么博客更新的这么慢?

  • 学习的难度在不断的增加,产出越来越慢

  • 比以前懒了?

今天要分享的是主要内容是Go语言Map底层实现,目的让大家快速了解Go语言Map底层大致的实现原理。读完本篇文章你可以获得收益、以及我所期望你能获取的收益如下:

收益序号收益描述掌握程度
收益1大致对Go语言Map底层实现有一个了解必须掌握
收益2大致知道Go语言Map是如何读取数据的必须掌握
收益3熟悉Go语言Map底层核心结构体hmap可选
收益4熟悉Go语言Map底层核心结构体bmap可选
收益5熟悉Go语言Map底层里的溢出桶可选
收益6熟悉Go语言Map是如何读取数据的可选

收益1和收益2是看了本篇文章希望大家必须掌握的知识点,其他的为可选项,如果你对此感兴趣或者已经掌握了收益1、2可以继续阅读此处的内容。

对于本篇文章的结构主要按如下顺序开展:

  • 简单看看一般Map的实现思路

  • Go语言里Map的实现思路(入门程度:包含收益1、2)

  • Go语言里Map的实现思路(熟悉程度:包含收益3、4、5、6)

其次,本篇文章主要以Map的读来展开分析,因为读弄明白了,其他的写、更新、删除等基本操作基本都可以猜出来了,不是么????。

简单看看一般Map的实现思路

直入主题,一般的Map会包含两个主要结构:

  • 数组:数组里的值指向一个链表

  • 链表:目的解决hash冲突的问题,并存放键值

大致结构如下:

读取一个key值的过程大致如下:

                  key
                   |
                   v                 
+------------------------------------+
|      key通过hash函数得到key的hash    |
+------------------+-----------------+
                   |
                   v
+------------------------------------+
|       key的hash通过取模或者位操作     |
|          得到key在数组上的索引        |
+------------------------------------+
                   |
                   v
+------------------------------------+
|         通过索引找到对应的链表         |
+------------------+-----------------+
                   |
                   v
+------------------------------------+
|       遍历链表对比key和目标key        |
+------------------+-----------------+
                   |
                   v
+------------------------------------+
|              相等则返回value         |
+------------------+-----------------+
                   |
                   v                
                 value


接着我们来简单看看Go语言里Map的实现思路。

Go语言里Map的实现思路(入门程度)

包含收益1、2

Go语言解决hash冲突不是链表,实际主要用的数组(内存上的连续空间),如下图所示:

备注:后面我们会解释上面为啥用的“主要”两个字。

但是并不是只使用一个数组(连续内存空间)存放键和值,而是使用了两个数组分别存储键和值,图示如下:

上图中:

  • 分别对应的是两个核心的结构体hmap和bmap

  • bmap里有两个数组分别存放key和value

把上面简化的关系转换一下,其实就是这样的一个大致关系,如下图所示:

我们通过一次读操作为例,看看读取某个key的值的一个大致过程:

步骤编号描述
①通过hash函数获取目标key的哈希,哈希和数组的长度通过位操作获取数组位置的索引(备注:获取索引值的方式一般有取模或位操作,位操作的性能好些)
②遍历bmap里的键,和目标key对比获取key的索引(找不到则返回空值)
③根据key的索引通过计算偏移量,获取到对应value

读过程图示如下:

这么看起来是不是“很简单”、很清晰,所以读到这里,你是不是已经入门了Go语言Map底层实现并且:

  • 大致对Go语言Map底层实现有一个了解(收益1)

  • 大致知道Go语言Map是如何读取数据的(收益2)

然而实际情况不止如此,我们再稍微深入的探索下,有兴趣的可以继续往下看,没兴趣可以不用继续往下看了(开玩笑=^_^=),反正已经达到目的了,哈哈????。

Go语言里Map的实现思路(熟悉程度)

包含收益3、4、5、6

想要深入学习,首先得了解下上面提到了实现Map的两个核心结构体hmap和bmap。

核心结构体hmap

收益3: 熟悉Go语言Map底层核心结构体`hmap`

hmap的结构其实刚开始看起来其实还是比较复杂的,有不少的字段,具体字段如下图所示:

字段释义如下:

字段解释
count键值对的数量
B2^B=len(buckets)
hash0hash因子
buckets指向一个数组(连续内存空间),数组的类型为[]bmap,bmap类型就是存在键值对的结构下面会详细介绍,这个字段我们可以称之为正常桶。如下图所示
oldbuckets扩容时,存放之前的buckets(Map扩容相关字段)
extra溢出桶结构,正常桶里面某个bmap存满了,会使用这里面的内存空间存放键值对
noverflow溢出桶里bmap大致的数量
nevacuate分流次数,成倍扩容分流操作计数的字段(Map扩容相关字段)
flags状态标识,比如正在被写、buckets和oldbuckets在被遍历、等量扩容(Map扩容相关字段)
备注:本次内容不涉及Map的扩容逻辑。

重点看一些字段的含义和用处。

字段buckets

buckets指向了一个数组(连续的内存空间),数组的元素是bmap类型,这个字段我们称之为正常桶。

hmap的源码和地址如下:

//https://github.com/golang/go/blob/go1.13.8/src/runtime/map.go
type hmap struct {
	count     int 
	flags     uint8
	B         uint8 
	noverflow uint16 
	hash0     uint32
	buckets    unsafe.Pointer
	oldbuckets unsafe.Pointer
	nevacuate  uintptr 
	extra *mapextra
}

核心结构体bmap

收益4: Go语言Map底层核心结构体`bmap`

正常桶hmap.buckets的元素是一个bmap结构。bmap的具体字段如下图所示:

字段释义如下:

字段解释
topbits长度为8的数组,[]uint8,元素为:key获取的hash的高8位,遍历时对比使用,提高性能。如下图所示
keys长度为8的数组,[]keytype,元素为:具体的key值。如下图所示
elems长度为8的数组,[]elemtype,元素为:键值对的key对应的值。如下图所示
overflow指向的hmap.extra.overflow溢出桶里的bmap,上面的字段topbits、keys、elems长度为8,最多存8组键值对,存满了就往指向的这个bmap里存
pad对齐内存使用的,不是每个bmap都有会这个字段,需要满足一定条件

推断出bmap结构字段的代码和位置如下:

//https://github.com/golang/go/blob/go1.13.8/src/cmd/compile/internal/gc/reflect.go
func bmap(t *types.Type) *types.Type {
  // 略...

  field := make([]*types.Field, 0, 5)

	field = append(field, makefield("topbits", arr))

  // 略...
  
	keys := makefield("keys", arr)
	field = append(field, keys)

  // 略...
  
	elems := makefield("elems", arr)
	field = append(field, elems)

  // 略...
  
	if int(elemtype.Align) > Widthptr || int(keytype.Align) > Widthptr {
		field = append(field, makefield("pad", types.Types[TUINTPTR]))
	}

  // 略...
  
	overflow := makefield("overflow", otyp)
	field = append(field, overflow)

  // 略...
}

结论:每个bmap结构最多存放8组键值对。

hmap和bmap的基本结构合起来

分别了解了hmap和bmap的基本结构后,我们把上面的内容合并起来,就得到如下的Map结构图:

溢出桶

收益5: 熟悉Go语言Map底层里的溢出桶

上面讲bmap的时候,我们不是得到了个结论么“每个bmap结构最多存放8组键值对。”,所以问题来了:

正常桶里的bmap存满了怎么办?

解决这个问题我们就要说到hmap.extra结构了,hmap.extra是个结构体,结构图示和字段释义如下:

字段解释
overflow称之为溢出桶。和hmap.buckets的类型一样也是数组[]bmap,当正常桶bmap存满了的时候就使用hmap.extra.overflow的bmap。所以这里有个问题正常桶hmap.buckets里的bmap是怎么关联上溢出桶hmap.extra.overflow的bmap呢?我们下面说。
oldoverflow扩容时存放之前的overflow(Map扩容相关字段)
nextoverflow指向溢出桶里下一个可以使用的bmap

源码和地址如下:

//https://github.com/golang/go/blob/go1.13.8/src/runtime/map.go
type mapextra struct {
	overflow    *[]*bmap
	oldoverflow *[]*bmap
	nextOverflow *bmap
}

问题:正常桶hmap.buckets里的bmap是怎么关联上溢出桶hmap.extra.overflow的bmap呢?

答:就是我们介绍bmap结构时里的bmap.overflow字段(如下图所示)。bmap.overflow是个指针类型,存放了对应使用的溢出桶hmap.extra.overflow里的bmap的地址。

问题又来了:

问题:正常桶hmap.buckets里的bmap是什么时候关联上溢出桶hmap.extra.overflow的bmap呢?

答:Map写操作的时候。这里直接看关键代码:

// https://github.com/golang/go/blob/go1.13.8/src/runtime/map.go
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
  // 略
again:
	// 略...
	var inserti *uint8
  // 略...
bucketloop:
	for {
		for i := uintptr(0); i < bucketCnt; i++ {
      // key的hash高8位不相等
			if b.tophash[i] != top {
        // 当前位置bmap.tophash的元素为空且还没有写入的记录(inserti已经写入的标记为)
				if isEmpty(b.tophash[i]) && inserti == nil {
          // inserti赋值为当前的hash高8位 标记写入成功
					inserti = &b.tophash[i]
					// 略...
				}
				// 略...
				continue
			}
			// 略...
			goto done
    }
    // 正常桶的bmap遍历完了 继续遍历溢出桶的bmap 如果有的话
		ovf := b.overflow(t)
		if ovf == nil {
			break
    }
		b = ovf
	}

  // 略...

  // 没写入成功(包含正常桶的bmap、溢出桶的bmap(如果有的话))
	if inserti == nil {
    // 分配新的bmap写
    newb := h.newoverflow(t, b)
    // 略...
	}

	// 略...
}

// 继续看h.newoverflow的代码
func (h *hmap) newoverflow(t *maptype, b *bmap) *bmap {
  var ovf *bmap
  // 如果hmap的存在溢出桶 且 溢出桶还没用完
	if h.extra != nil && h.extra.nextOverflow != nil {
    // 使用溢出桶的bmap
    ovf = h.extra.nextOverflow
    // 判断桶的bmap的overflow是不是空
    // 这里很巧妙。为啥?
    // 溢出桶初始化的时候会把最后一个bmap的overflow指向正常桶,值不为nil
    // 目的判断当前这个bmap是不是溢出桶里的最后一个
		if ovf.overflow(t) == nil {
      // 是nil
      // 说明不是最后一个
			h.extra.nextOverflow = (*bmap)(add(unsafe.Pointer(ovf), uintptr(t.bucketsize)))
		} else {
      // 不是nil
      // 则重置当前bmap的overflow为空
      ovf.setoverflow(t, nil)
      // 且 标记nextOverflow为nil 说明当前溢出桶用完了
			h.extra.nextOverflow = nil
		}
	} else {
    // 没有溢出桶 或者 溢出桶用完了
    // 内存空间重新分配一个bmap
		ovf = (*bmap)(newobject(t.bucket))
  }
  // 生成溢出桶bmap的计数器计数
	h.incrnoverflow()
  // 略...
  // 这行代码就是上面问题我们要的答案:
  // 正常桶`hmap.buckets`里的`bmap`在这里关联上溢出桶`hmap.extra.overflow`的`bmap`
	b.setoverflow(t, ovf)
	return ovf
}

// setoverflow函数的源码
func (b *bmap) setoverflow(t *maptype, ovf *bmap) {
  // 这行代码的意思:通过偏移量计算找到了bmap.overflow,并把ovf这个bmap的地址赋值给了bmap.overflow
	*(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-sys.PtrSize)) = ovf
}

下面代码这段代码解释了,上面的源码中为何如此判断预分配溢出桶的bmap是最后一个的原因。

// https://github.com/golang/go/blob/go1.13.8/src/runtime/map.go
// 创建hmap的正常桶
func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
  // 略...
	if base != nbuckets {
    // 略...
    last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize)))
    // 把溢出桶里 最后一个 `bmap`的`overflow`指先正常桶的第一个`bmap`
    // 获取预分配的溢出桶里`bmap`时,可以通过判断overflow是不是为nil判断是不是最后一个
		last.setoverflow(t, (*bmap)(buckets))
  }
  // 略...
}

当hmap存在溢出桶时,且当前溢出桶只被使用了一个bmap时,我们可以得到如下的关系图:

同时我们可以看出正常桶的bmap和溢出桶的bmap实际构成了链表关系,所以这也解释了开篇我们说到的“Go里面Map的实现主要用到了数组”,其次还用到了链表。

再次分析Map的读

收益6: 熟悉Go语言Map是如何读取数据的

通过上面的学习,我们再次通过一次读操作为例,看看读取某个key的值的一个大致过程:

结合代码分析下整个大体的过程:

func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
    // ...略
    
    // ①通过hash函数获取当前key的哈希
	hash := alg.hash(key, uintptr(h.hash0))
    m := bucketMask(h.B)
    // ②通过当前key的哈希获取到对应的bmap结构的b
    // 这里的b 我们称之为“正常桶的bmap”
    // “正常桶的bmap”可能会对应到溢出桶的bmap结构,我们称之为“溢出桶的bmap”
    b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
    
    // ...略
    
    // 获取当前key的哈希的高8位
	top := tophash(hash)
bucketloop:
    // 下面的for循环是个简写,完整如下。
    // for b = b; b != nil; b = b.overflow(t) {
    // 可以知道b的初始值为上面的“正常桶的bmap”,则:
    // 第一次遍历:遍历的是“正常桶的bmap”
    // 如果正常桶没找到,则
    // 绿色线条④ 继续遍历:如果当前“正常桶的bmap”中的overflow值不为nil(说明“正常桶的bmap”关联了“溢出桶的bmap”),则遍历当前指向的“溢出桶的bmap”继续 重复蓝色线条的③④⑤步骤
	for ; b != nil; b = b.overflow(t) {
        // 由于b的初始值为“正常桶的bmap”,第一次先遍历“正常桶的bmap”
		for i := uintptr(0); i < bucketCnt; i++ {
            // 蓝色线条③ 对比key哈希的高8位
            // 对比哈希的高8位目的是为了加速
			if b.tophash[i] != top {
                // emptyRest 标志位:表示当前位置已经是末尾了;删除操作会设置此标志位
				if b.tophash[i] == emptyRest {
					break bucketloop
				}
				continue
            }
            // 找到了相同的hash高8位,则:找到对应索引位置i的key
			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
			if t.indirectkey() {
				k = *((*unsafe.Pointer)(k))
            }
            // 蓝色线条④ 对比key是不是一致
			if alg.equal(key, k) {
                // 蓝色线条⑤ key是一致,则:获取对应索引位置的值
				e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
				if t.indirectelem() {
					e = *((*unsafe.Pointer)(e))
                }
                // 返回找到的结果
				return e
			}
		}
    }
    // 正常桶、溢出桶都没找到则返回 “空值”
	return unsafe.Pointer(&zeroVal[0])
}

结语

原创不易,年底了,征一波稿费,1元就行,在此谢过大家。

参考:
1.《Go语言设计与实现》https://draveness.me/golang/docs/part2-foundation/ch03-datastructure/golang-hashmap/
2. Go源码版本1.13.8 https://github.com/golang/go/tree/go1.13.8/src

Go设计模式实战系列 更多文章

  1. 并发组件 | Go设计模式实战 

  2. 代码模板 | Go设计模式实战 

  3. 链式调用 | Go设计模式实战 

  4. 代码组件 | Go设计模式实战 

  5. 订阅通知 | Go设计模式实战 

  6. 客户决策 | Go设计模式实战 

  7. 状态变换 | Go设计模式实战 

Go语言之map:map的用法到map底层实现分析 带着几个问题阅读本文: 1. go map 实现方法?如何解决hash冲突的? 2. go map是否线程安全? 3. go map 的扩容机制? 什么是map? 由一组 <key, value> 对组成的抽象数据结构,并且同一个 key 在map中只会出现一次 map 的设计也被称为 “The dictionary problem”,它的任务是设计一种数据结构用来维护一个集合的... 阅读详情

相关推荐

go语言DAY7 字典Map 指针 结构体 函数

这样就把所有散列的map元素按哈希值与队列数的模值这样的规律放好,将来想找到某一个map元素,就根据模值找到这个元素所在的队列,在根据这个元素的哈希值具体查找到这个元素,这样的话效率对比查找某个map值需要遍历整个map集合来说效率就高了3/4。哈希值与B的&运算,但是B值与哈希值相比较高位全部为0,高位&运算的二进制结果都为0,没有意义,通常取哈希值低B位进行运算得到对应标准桶的索引下标。也不能是嵌套的切片,map类型。bmap代表的是桶数组中的桶对象,bmap负责存储key,value值。

weixin_45939821的博客 1011

GO中map底层详解

bucket数组中每个元素都是bmap结构的,bmap中存储着8个key-value的键值对,如果是满了的话,当再来一个键值对的时候就会放到下一个溢出桶中,同时是通过这个overflow进行连接。时机:溢出桶过多:由于map中不断的put和delete key,桶中可能会出现很多断断续续的空位,这些空位会导致连接的bmap溢出桶很长,导致扫描时间边长。当我们遍历一个正在迁移的Map时,新的和旧的就会遍历,如果一个旧的的桶已经迁移走了,那么就直接跳过,反正不在旧的就在新的里。

qq_58244272的博客 2586

Argoverse轨迹预测实战:从数据加载到地图API应用全解析

本文详细解析了Argoverse数据集在轨迹预测中的应用,从数据加载到地图API的实战技巧全涵盖。通过具体代码示例展示如何高效处理轨迹数据、实现可视化及基础预测模型,帮助开发者快速掌握自动驾驶轨迹预测的核心技术。特别介绍了Argoverse地图API的深度应用和性能优化经验。

weixin_29182481的博客 242

map-go

----------------哈希表------------ https://segmentfault.com/a/1190000018380327?utm_source=tag-newest 知识点总结 map 分为hmap和bmap hmap 中有count 记录元素个数,所以len事件复杂度是O(1) hmap中bucket只想每个bucket的地址 overflow指向溢出的bucket,每个bucket只能存储8个键值对 oldbuckets 是map进行rehash的时候使用的,为buc

a...Z 633

实战指南:基于ELK与Grafana构建天融信防火墙日志可视化看板

本文详细介绍了如何基于ELK与Grafana构建天融信防火墙日志可视化看板,包括环境准备、日志收集与解析配置、Elasticsearch存储优化、Grafana看板设计等关键步骤。通过实战案例和优化技巧,帮助用户高效处理天融信防火墙日志,实现安全态势的可视化监控与分析。

weixin_34246529的博客 227

ES8311音频Codec避坑指南:从I2C通信、电平匹配到回环测试的保姆级调试笔记

本文详细解析了ES8311音频编解码芯片的调试全流程,涵盖I2C通信建立、电平匹配、主从模式配置等关键环节。通过真实案例和实用技巧,帮助工程师快速定位和解决音频Codec常见问题,提升硬件调试效率。特别针对回环测试、功耗分析等高频故障点提供了可复用的排查方法论。

weixin_42532938的博客 278

【Go】Go 中 Map 的实现原理

最后我们分析一下go的整体内存结构,阅读一下map存储的源码,如下图所示,当往map中存储一个kv对时,通过k获取hash值,hash值的低八位和bucket数组长度取余,定位到在数组中的那个下标,hash值的高八位存储在bucket中的tophash中,用来快速判断key是否存在,key和value的具体值则通过指针运算存储,当一个bucket满时,通过overfolw指针链接到下一个bucket。扩容过程中,Go 会创建一个更大的桶数组,并将现有的键值对重新分配到新的桶中。总结起来,Go 中的。

Fanjufei的博客 527

数据分析学习总结笔记02:聚类分析及其R语言实现

** 数据分析学习总结笔记02:聚类分析Cluster Analysis ** 1. 聚类分析概述 1.1 聚类分析的直观理解 在科学研究、社会调查或日常生活中,通过观察个体的特征,将群体中的个体归为不同的族群/簇(Cluster)。 2. 聚类分析的方法 3. 聚类分析的应用 3.1 市场营销——精准营销 在市场营销中,基于消费者的历史交易信息、消费者背景等对消费者进行划分,从而对不同类型的消费...

weixin_41961559的博客 4423

Go语言实现原理——Map实现原理

Map这一数据结构在很多语言中都存在,其查询的效率非常高,时间复杂度在O(1)的级别,其底层原理使用的是哈希表,通过计算的值,找到其所在的,然后再通过寻找其, 流程如下图所示由于bucket的数量有限,而k-v对的数量会越来越多,因此,在通过哈希值查找对应的bucket的时候可能出现多个哈希值对应一个bucket的情况,这就是hash碰撞。为解决这个问题,可以通过或来解决此类问题如果多个元素被放在一个bucket中,则会将他们以链表的形式组织起来,在查找到对应的bucket后,只需要对其进行遍历即可。缺点:

生命中有太多不确定 2772

积木报表导出数据量太大报错

‌性能问题‌:‌当数据量非常大时,‌积木报表在导出过程中可能会遇到性能瓶颈,‌导致导出过程缓慢甚至失败。‌解决这一问题的方法包括优化SQL查询、‌调整分页大小、‌使用更适合处理大量数据的库(‌如阿里巴巴的EasyExcel)‌进行导出,‌或者采用异步处理的方式来避免接口超时1。‌内存溢出‌:‌如果报表工具或其依赖的库不支持流式(‌分批)‌导出,‌大量数据的处理可能会导致内存溢出。‌数据处理方式‌:‌如果待导出的数据包含特殊字符,‌如英文双引号或等号,‌这可能导致JSON反序列化报错。

Activiti工作流 1909

网络虚拟化介绍(OVS、DVS)

网络虚拟化概念网络虚拟化就是把网络层的一些功能从硬件中剥离出来,建立新的网络虚拟层;该虚拟层可以接管网络服务和配置,实现网络服务与物理层的解耦,打破物理资源限制;通过网络虚拟层能够在一个物理网络上模拟出多个逻辑网络,并且多用户在逻辑网络上相互隔离,保证网络安全网络虚拟化的特点隔离性:不同租户的流量相互之间不能互访;但是IP/MAC地址都可以独立规划可移动性:虚拟机可以跨二层/三层迁移,甚至可以跨广域网迁移(迁移前后虚拟机Vlan和IP地址都不会发生变化)可扩展性:逻辑网络的规模和数量可扩展。

m0_49864110的博客 1万+

Go Map底层实现原理

文章目录前言1. map数据结构2. bucket 数据结构3. 哈希冲突 前言 说到键值对的存储,我们通常会想到哈希表,而哈希表通常会有一堆桶来存储键值对,一个键值对来了自然要选择一个桶,怎么选? 先通过哈希函数把键处理一下,得到一个哈希值,从m个桶中选择一个,桶编号区间 [0, m-1] 方法1:取模法 hash % m 方法2:与运算法 1. map数据结构 map类型的变量本质上是一个指针,指向 *hmap 结构体 type hmap struct { count int

爱意时刻减淡,玫瑰不再浪漫 3424

【Unity引擎技术整合】 Unity学习路线 | 知识汇总 | 持续更新 | 保持乐趣 | 共同成长

本文对Unity引擎的知识进行了一个整理总结,基本包含了Unity中大部分的知识介绍。 网上也有很多Unity相关的学习资料,但大多数都不成体系,学起来的时候难免会东奔西走的摸不着头脑。 本文整理的多数文章都是有对应的系列性文章专栏,可以更方便的进行系统学习相关知识体系。

努力前行,总会成为自己心中的那道光 15万+

【Go语言精进之路】构建高效Go程序:了解map实现原理并高效使用

在Go语言中,map 是一种无序的键值对集合,它以其高效的查找、插入和删除操作而闻名。了解 map 的基本概念、特性和内部实现机制,对于编写高效且稳定的Go代码至关重要。本文将深入探讨 map 的各个方面,包括其初始化、基本操作、内部实现细节,并讨论为何在创建 map 时应尽量使用带有容量提示参数的做法。

Allen- 3605

Sigrity Power DC Resitance Network Model Generation模式生成电阻SPICE模型操作指导

Sigrity Power DC Resitance Network Model Generation模式是用于提取负载每个pin电阻SPICE模型的,结果以spice网表形式展现,仍然以Motherboard.spd为例进行说明。目的是模拟实际情况,via的孔壁电镀1mil,中间是空心的,让via不完全被填充金属成为实心via。Upper/lower Tolerance:上下公差,设置为5%,也就是压降允许的范围。P/F Mode:通过/失败模式,选择Worst,最差的情况。

weixin_54787054的博客 420

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Go语言探秘——Map

由于插入了很多元素,在不是完全理想的情况下,肯定会创建一些溢出桶,但是,又由于没有达到负载因子的临界值,所以不会触发扩容,在删除很多元素,这个时候负载因子又会减小,再插入很多元素,会继续创建更多的溢出桶,导致查找元素的时候要去遍历很多的溢出桶链表,性能下降,所以在这种情况下要进行扩容,新建一个桶数组,把原来的数据拷贝到里面,这样数据排列更紧密,查找性能更快。这是因为go在每次开始遍历前,都会随机选择一个桶下标,一个桶内遍历的起点槽下标,遍历的时候从这个桶开始,在遍历每个桶的时候,都从这个槽下标开始。

IT杨秀才的博客 3505

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Go语言入门之Map详解

name:变量名key_type:键的类型value_type:值的类型// 方式一// 方式二1 : "老一",2 : "老二",3 : "老三",// 方式三:5代表容量,也就是在内存中占用多大的空间,可以省略。

clisks的博客 1597

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

【GO】map 实现原理

深入源码学习golang的map结构

weixin_73815624的博客 1387

Go语言map的底层原理

hmap结构hmap是map的顶层结构,包含了管理map操作所需要的各类元数据。(比如哈希种子,桶的数量,桶的地址)其次hmap通过buckets字段(指针类型)引用了所有的bucket。buckets是一个指向bucket数组的指针,数组中的每一个元素就是一个bmap。bmap结构bamp是实际存储键值对的结构。每一个bamp可以存储多个键值对,并且包含溢出指针,用来处理哈希冲突的情况。bmap结构内的数组包含了多个键值对槽位 (key/val。

2303_79710813的博客 1578

【go】go语言slice/map的产生背景,及原理理解

先讲一下slice的产生背景,首先,go本身是有数组的,但是不会自动扩容,然而实际工作中会有很多场景是要求能自动扩容的,比如说你接用户的数据,你肯定要设置一个可以自动扩容的数组来接,因为你没办法预测他会传多大的数据,提前设置的数组过大或者过小都不合适,因此,go的slice应运而生slice结构包含一个指向底层数组的指针长度容量。这样的设置就可以看出他是一个轻量级的容器,因为实际上只是一个对底层数组的引用。slice的扩容机制,在长度超过容量的时候,如果容量<1024那么双倍。

m0_74282926的博客 1644

Go语言中的Map:并发安全的实现

sync.Map是Go语言中用于实现并发安全map的一个类型,它可以帮助开发者在多个协程中安全地访问map。通过理解sync.Map的原理和最佳实践,我们可以编写更加高效、可靠的并发程序。选择合适的场景:sync.Map适合读多写少、键值对数量不确定的场景避免滥用:对于读少写多的场景,使用互斥锁+普通map可能更好类型安全封装:使用类型安全的封装来避免类型断言失败及时清理:及时删除不再使用的键值对,避免内存泄漏性能优化:尽量减少单个操作,避免频繁遍历。

好代码自己会说话,烂代码才需要注释来圆谎 3547

go map 实现原理

维基百科里这样定义 map:简单说明一下:在计算机科学里,被称为相关数组、map、符号表或者字典,是由一组对组成的抽象数据结构,并且同一个 key 只会出现一次。有两个关键点:map 是由key-value对组成的;key只会出现一次。增加一个 k-v 对 —— Add or insert;删除一个 k-v 对 —— Remove or delete;修改某个 k 对应的 v —— Reassign;查询某个 k 对应的 v —— Lookup;简单说就是最基本的增删查改。

daemon365的博客 1009

【Golang】Go语言Map详解

文章介绍golang map的一些基本使用方法。进一步地用图表的方式展示了map涉及的数据结构。

Daniel的博客 1549

Runtime:源码解析Golang 的map实现原理

map不是并发安全的,所以在源码里有大量的代码判断在赋值时会设置map处于协程写的状态遍历map是无序的,因为随着元素的添加和删除会进行扩容,元素位置会发生变化。

qq_24428851的博客 1904

golang:map 的底层实现原理是什么

源自go map底层 一、什么是 map 维基百科里这样定义 map: In computer science, an associative array, map, symbol table, or dictionary is an abstract data type composed of a collection of (key, value) pairs, such that each possible key appears at most once in the collection. 简单说

weixin_42248522的博客 2694
上一篇: 并发组件 | Go设计模式实战
下一篇: 过去2020,未来2021
TIGERB_Blog
博客等级 码龄10年 109粉丝 65原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值