go map 300多万长度的如何快速操作?

Question

//如输入[1 2 3]，则返回[123 132 213 231 312 321]
func outOrder(trainsNums []string) []string {
    COUNT := len(trainsNums)
    //检查
    if COUNT == 0 || COUNT > 10 {
        panic("Illegal argument. trainsNums size must between 1 and 9.")
    }
    //如果只有一个数，则直接返回
    if COUNT == 1 {
        return []string{trainsNums[0]}
    }
    //否则，将最后一个数插入到前面的排列数中的所有位置（递归）
    return insert(outOrder(trainsNums[:COUNT-1]), trainsNums[COUNT-1])
}
func insert(res []string, insertNum string) []string {
    //保存结果的slice
    result := make([]string, len(res)*(len(res[0])+1))
    index := 0
    for _, v := range res {
        for i := 0; i < len(v); i++ {
            //在v的每一个元素前面插入
            result[index] = v[:i] + insertNum + v[i:]
            index++
        }
        //在v最后面插入
        result[index] = v + insertNum
        index++
    }
    return result
}

func main(){
    init := []string{
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "0",
    }
    arr := outOrder(init)
    list = make(map[string]int)
    for _,v := range arr {
        list[v] = 0
    }
}

以上代码生成出来的数组长度在380万.假设我要找key的中第4位包含4的所有字符串,要这么找呢.
key是一串10位数字不重复的字符串

目前使用数据库中memory引擎,还是不能达到我的要求

CREATE TABLE `mem` (
  `k1` tinyint(2) NOT NULL,
  `k2` tinyint(2) NOT NULL,
  `k3` tinyint(2) NOT NULL,
  `k4` tinyint(2) NOT NULL,
  `k5` tinyint(2) NOT NULL,
  `k6` tinyint(2) NOT NULL,
  `k7` tinyint(2) NOT NULL,
  `k8` tinyint(2) NOT NULL,
  `k9` tinyint(2) NOT NULL,
  `k10` tinyint(2) NOT NULL,
  `t1` tinyint(1) DEFAULT NULL,
  `t2` tinyint(1) DEFAULT NULL,
  `t3` tinyint(1) DEFAULT NULL,
  `t4` tinyint(1) DEFAULT NULL,
  `t5` tinyint(1) DEFAULT NULL,
  `he` tinyint(2) DEFAULT NULL,
  `bonus` float DEFAULT NULL,
  PRIMARY KEY (`k1`,`k2`,`k3`,`k4`,`k5`,`k6`,`k7`,`k8`,`k9`,`k10`),
  KEY `k1` (`k1`) USING HASH,
  KEY `k2` (`k2`) USING HASH,
  KEY `k3` (`k3`) USING HASH,
  KEY `k4` (`k4`) USING HASH,
  KEY `k5` (`k5`) USING HASH,
  KEY `k6` (`k6`) USING HASH,
  KEY `k7` (`k7`) USING HASH,
  KEY `k8` (`k8`) USING HASH,
  KEY `k9` (`k9`) USING HASH,
  KEY `k10` (`k10`) USING HASH,
  KEY `t1` (`t1`) USING HASH,
  KEY `t2` (`t2`) USING HASH,
  KEY `t3` (`t3`) USING HASH,
  KEY `t4` (`t4`) USING HASH,
  KEY `t5` (`t5`) USING HASH,
  KEY `he` (`he`) USING BTREE
) ENGINE=MEMORY DEFAULT CHARSET=utf8;

需求:
分别更新k2字段0-9 10个数字的bonus字段的数字,分别+1,+2,+10,这样就需要10个update 每个更新需要0.5秒,更新多个字段的时候时间太久了.

Answer 1

如果不考虑使用更优的算法的情况下，把key读到内存数组中，然后遍历找到第4位包含4的所有字符串，然后再从map中找到value，是比较简单的方法了。

Answer 2

对数组进行切分，并发访问。
补充一点：如果生成的数组，是有一定顺序的（我看你的举例中是有序的）那么可以借鉴二分查找的思想来定位，减少不必要的查询。 当我没说

Answer 3

可以从「先优化数据结构」再「查找」方向思考。

真实场景下，300w 条的数据量，可以考虑引入数据库了