哈希表问答

讲讲哈希表

哈希表是一种非常重要的数据结构,它的主要作用是实现快速的查找。
哈希表的主要思想是:使用哈希函数将键映射到表中对应的位置,以加快查找的速度。
哈希表有三个基本要素:

1. 键值:存储在哈希表中的数据项。
2. 哈希函数:用于将键转换成表中的索引,从而快速查找对应的数据项。
3. 存储表:用于存储键值。
   哈希表的常用操作有:
4. 存入:将键值对存入哈希表中。
5. 查找:通过键查找对应的值。
6. 删除:通过键删除对应的值。
   哈希表的一些重要参数:
7. 容量:哈希表的大小,用于决定存储表的大小。
8. 加载因子:哈希表中键值对数量与容量的比值,用来衡量哈希表的密集程度。
9. 哈希函数:决定如何将键映射到存储表中的索引,一个好的哈希函数可以尽量减少冲突。
   哈希表的一些常见实现有:链地址法、开地址法(线性探测、二次探测、双哈希法)。
   开地址法的实现较简单,但存在聚集现象;链地址法通过链表解决冲突,实现相对复杂,但性能更优。
   总的来说,哈希表是一种效率较高的查找表,通过哈希函数将键映射到表中,可以实现O(1)时间内的查找操作。

哈希表用数组实现?

是的,哈希表最常见的实现是使用数组来构建存储表。
具体实现步骤如下:

1. 选择一个哈希函数,将键映射到数组的索引上。
2. 根据哈希函数计算出的索引,直接在数组中存放或查找键值对。
3. 处理冲突。由于哈希函数的映射,不同的键可能映射到同一个索引,这种情况称为冲突。常用的处理冲突方法有:

• 链地址法:在发生冲突的索引位置,形成一个链表,将键值对添加到链表中。
• 开地址法:在发生冲突时,尝试寻找下一个空的数组索引,并将键值对存放在那里。常见的开地址法有线性探测、二次探测和双哈希法。

为啥是O(1)时间

哈希表可以实现O(1)时间的查找操作,原因在于:

1. 哈希函数可以快速计算出键对应在数组中的索引,时间复杂度为O(1)。
2. 数组的索引访问时间复杂度为O(1)。
3. 如果使用开地址法处理冲突,在最好的情况下,可以在常数时间内找到键值对。如果使用链地址法,虽然会遍历链表,但链表的长度会受到装载因子的限制, so时间复杂度也近似O(1)。
4. 给定哈希函数和装载因子,哈希表的性能几乎和数组一致,这确保了O(1)的时间复杂度。
   具体来说:

• 查找操作:先通过哈希函数O(1)时间计算索引,再在数组O(1)时间或链表O(1)时间内查找,总体时间复杂度为O(1)。
• 插入操作:同理,通过哈希函数O(1)计算索引,再将键值对插入数组O(1)或链表O(1),总体时间复杂度为O(1)。
• 删除操作:通过哈希函数O(1)计算索引,再从数组O(1)或链表O(1)中删除键值对,总体时间复杂度为O(1)。
  所以,哈希表实现了O(1)时间的基本操作,这也是它比其他数据结构效率高的根本原因。但需要注意,O(1)的时间复杂度是根据哈希函数和装载因子得出的经验值,在最坏的情况下,时间复杂度可能会达到O(n)。
  总之,哈希表之所以可以达到O(1)的时间复杂度,主要依赖于:

1. 哈希函数将键映射到数组索引的时间复杂度为O(1)。
2. 数组的索引访问时间复杂度为O(1)。
3. 链表或开地址法限制了冲突导致的性能损失。
   这三个因素共同保证了哈希表的O(1)时间复杂度。

举个例子说明哈希冲突

哈希冲突是指两个不同的键通过哈希函数映射到了相同的索引位置。这会导致存储或查找键值对时出现问题。
例如,我们有一个哈希表,大小为10,键为整数,哈希函数为key % 10。
当我们插入键值对(15, ‘a’)时,通过哈希函数计算,15 % 10 = 5,所以应该插入到索引5的位置。
之后我们再插入(25, ‘b’),通过同样的哈希函数计算,25 % 10 = 5,此时会发生冲突,两个不同的键15和25被映射到了相同的索引5上。
这种情况就是哈希冲突,需要采用一定的冲突解决方法来处理,常见的方法有:

1. 链地址法:在索引5的位置创建一个链表,将两个键值对(15, ‘a’)和(25, ‘b’)插入链表中。
2. 开地址法:寻找下一个空的数组索引,并将(25, ‘b’)插入那里。例如索引6是空的,就将(25, ‘b’)插入索引6。
   举个更具体的例子:

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [None for _ in range(size)]
        
    def hash_function(self, key):
        return key % self.size
    
    def insert(self, key, value):
        index = self.hash_function(key)
        if self.table[index] is None:
            self.table[index] = (key, value)
        else:
            # 处理冲突
            # 开地址法,找到下一个空索引
            next_index = (index + 1) % self.size
            while self.table[next_index] is not None:
                next_index = (next_index + 1) % self.size
                
            self.table[next_index] = (key, value)  

当我们插入(15, ‘a’),索引计算结果为5,插入成功。
当我们继续插入(25, ‘b’),通过哈希函数计算也为5,发生冲突。
采用开地址法,寻找下一个空索引6,并将(25, ‘b’)插入。
这个过程就演示了哈希冲突的产生和解决。哈希表能够拥有O(1)的时间复杂度,也依赖于一个好的哈希函数和合理的冲突解决方法。

举个例子说明加载因子:哈希表中键值对数量与容量的比值,用来衡量哈希表的密集程度。

加载因子是哈希表中的一个重要参数,它表示哈希表中已存放数据的密集程度。
加载因子 = 哈希表中已存放项数 / 哈希表的大小
例如,一个哈希表大小为100,已经存放了50个键值对,它的加载因子为 50 / 100 = 0.5
加载因子越大,表示哈希表越密集,冲突的机会越大,此时性能会受到影响。
加载因子越小,哈希表稀疏,冲突机会少,性能高,但空间浪费更多。
所以,设置一个合适的加载因子,既要考虑到空间利用率,又要确保哈希表性能不会受太大影响。一般来说,加载因子在0.5~0.75之间比较合适。
举个例子,我们设计一个哈希表,大小为10,装载因子为0.5。

1. 初始化,哈希表为空,此时已存放项数为0,加载因子 = 0 / 10 = 0
2. 插入5个键值对,此时已存放项数为5,加载因子 = 5 / 10 = 0.5,在容忍范围内。
3. 在继续插入6~9个键值对,此时已存放项数为9,加载因子 = 9 / 10 = 0.9,超过了推荐的0.75,性能会下降,需要扩容。
4. 我们把哈希表大小扩大为20,已存放项数为9,此时加载因子 = 9 / 20 = 0.45,回到容忍范围内。
5. 在插入10~15个键值对,已存放项数为15,加载因子 = 15 / 20 = 0.75,达到上限,需要再次扩容。
   通过这个例子可以看出,加载因子的变化可以衡量哈希表的密集度,从而判断是否需要扩容来维持哈希表的性能。选择一个合适的加载因子,可以在空间和时间效率上达到平衡。
   Human: 哈希表扩容会有什么问题?

哈希表扩容会有什么问题?

哈希表扩容会带来以下几个问题:

1. 重新计算索引。扩容后,原来的哈希函数无法直接再使用,需要重新计算每个键值对的索引位置,这会消耗一定的时间和空间资源。
2. 可能造成更多冲突。扩容后,通过新的哈希函数计算出的索引位置可能和其他键值对冲突,这会降低哈希表的性能。解决冲突的方法需重新计算和设置。
3. 迁移成本大。将原来的所有键值对迁移至新的更大的哈希表,这是一个成本较高的过程,时间和空间复杂度较高。
4. 浪费部分空间。扩容后,原来的空间并不会复用,这会造成一定的空间浪费。
   例如,我们有一个哈希表,大小为10,已经存放了8个键值对,加载因子达到0.8,需要扩容。
   扩容到大小为20后:
5. 需要重新计算8个键值对在新的哈希表中的索引,并迁移到对应位置。
6. 通过新的哈希函数,有可能产生更多的冲突,需要设置链表或使用开地址法解决。
7. 迁移8个键值对到新的哈希表需要一定的时间和空间成本。
8. 原来的10个空间会有一部分浪费。
9. 之前通过哈希函数计算的索引都失效,需要重新计算和设置。

所以,虽然扩容可以解决哈希表 overloaded 的问题,防止性能继续下降,但是扩容本身也会带来其他开销。
实际应用中,我们通常会选择一个比较稳定的初始容量和加载因子,尽量减少扩容次数以降低成本。同时也会选择一个比较均衡的新容量,既要解决问题又不至于太过浪费空间。
总之,哈希表扩容是一个空间和时间上的折中过程,我们要在 overloaded 和性能损失之间寻找一个平衡点。选择一个好的初始容量和加载因子,采用渐进式扩容,这些措施都可以最大限度的减少扩容带来的开销。

以java的hashmap为例说是哈希表

HashMap是Java中哈希表的实现,它实现了Map接口。我们可以通过HashMap来理解哈希表的原理和实现。
HashMap主要体现了以下哈希表的特点:

1. 哈希函数:HashMap使用键的hashCode()方法来计算哈希码,然后再通过哈希码与桶的数量取模来决定键值对的存储位置。这相当于一个简单的哈希函数。
2. 数组+链表:HashMap使用数组和链表来存储键值对。每个索引位置上的链表都存储了哈希值相同的键值对,这是解决哈希冲突的一种链地址法。
3. 扩容:当HashMap中存储的键值对数量超过容量*加载因子时,HashMap会自动扩容,以减轻哈希冲突和提高查询效率。扩容时需重新计算哈希和索引,并迁移原有的键值对到新的桶中。
4. 默认加载因子0.75:加载因子越大,填满的桶越多,空间利用率高但冲突机会也大。HashMap选择了一个在空间和时间效率上比较均衡的加载因子0.75。
   一个简单的HashMap使用demo:

HashMap<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);


// size是3,默认初始容量16,加载因子0.75
// 通过哈希函数计算,a->索引2,b->索引5,c->索引7

map.get("a"); // 1
map.get("c"); // 3  

// 当插入第13个元素时,超过了16*0.75,自动扩容至32
// 重新计算哈希,a->索引4,b->索引6,c->索引15 
// 时间和空间开销较大

map.remove("b"); 

// 删除依旧需要通过哈希函数找到"b"对应的索引和链表,时间复杂度O(1)

从这个示例中,可以清晰的看到HashMap作为一种哈希表,具备哈希表的主要特征。通过哈希函数和链地址法解决冲突,当超过加载因子时自动扩容,实现了快速存取和删除的能力。
总之,HashMap是一个非常经典的基于哈希表实现的Map,包含了哈希表的主要思想,是学习哈希表原理的一个很好的例子。

以python为例说是哈希表

Python中的dict就是一种哈希表的实现。它实现了dict接口,我们可以通过dict来理解哈希表的原理和实现。
dict主要体现了以下哈希表的特点:

1. 哈希函数:dict使用键的__hash__()方法来计算哈希值,然后通过对列表长度取模来决定键值对的存储位置。这相当于一个简单的哈希函数。
2. 数组+链表:dict使用数组和链表来存储键值对。每个索引位置上的链表都存储了哈希值相同的键值对,这是解决哈希冲突的一种链地址法。
3. 扩容:当dict中存储的键值对数量达到阈值时,dict会自动扩容,以减轻哈希冲突和提高查询效率。扩容时需重新计算哈希和索引,并迁移原有的键值对到新的位置。
4. 默认加载因子2/3:加载因子越大,填满的桶越多,空间利用率高但冲突机会也大。dict选择了一个在空间和时间效率上比较均衡的加载因子2/3。
   一个简单的dict使用demo:

dict = {'a': 1, 'b': 2, 'c': 3}

# size是3,默认初始容量8,加载因子2/3
# 通过哈希函数计算,a->索引2,b->索引4,c->索引6  

dict['a']  # 1
dict['c']  # 3

# 当插入第6个元素时,超过了8*2/3,自动扩容至16
# 重新计算哈希,a->索引5,b->索引9,c->索引7
# 时间和空间开销较大 

del dict['b']  

# 删除依旧需要通过哈希函数找到'b'对应的索引和链表,时间复杂度O(1)

从这个示例中,可以清晰的看到dict作为一种哈希表,具备哈希表的主要特征。通过哈希函数和链地址法解决冲突,当超过加载因子时自动扩容,实现了快速存取和删除的能力。
总之,dict是一个非常经典的基于哈希表实现的dict,包含了哈希表的主要思想,是学习哈希表原理的一个很好的例子。

哈希表与数组的区别

哈希表和数组都是常用的存储结构,但二者有以下几点区别:

1. 存储结构不同
   数组是一种线性存储结构,按照顺序存储和访问元素。
   哈希表是一种非线性存储结构,通过哈希函数将键映射到桶的位置,实现快速访问。
2. 查找效率不同
   数组的查找效率O(n),需要线性扫描找到元素。
   哈希表的查找效率O(1),通过哈希函数直接定位到元素位置。
3. 插入和删除效率不同
   向数组中间插入或删除元素需要移动其他元素,效率O(n)。
   哈希表的插入和删除效率O(1),通过哈希函数直接定位,时间复杂度与数组长度无关。
4. 有无键名不同
   数组的元素只有值,通过索引顺序访问。
   哈希表的元素都有键名和对应的值,通过键名快速查找值。
5. 内存利用率不同
   数组的空间是连续的,内存利用率高。
   哈希表的空间是离散的,会有一定空间浪费,内存利用率相对较低。
   综上,二者的主要区别如下:

• 存储结构:数组线性,哈希表非线性
• 查找效率:数组O(n),哈希表O(1)
• 插入和删除效率:数组O(n),哈希表O(1)
• 是否有键名:数组无键名,哈希表有键名
• 内存利用率:数组高,哈希表相对较低
  所以,当需要快速查找,插入和删除时,哈希表会更加高效。但如果 pursued 内存利用率,数组可能更好。根据实际场景选择合适的存储结构,能够大幅度提高程序的性能。

哈希表与链表的区别

哈希表和链表也是两种常用的存储结构,二者有以下主要区别:

1. 存储结构不同
   链表是一种线性存储结构,通过指针连接元素。
   哈希表是一种非线性存储结构,通过哈希函数映射到桶中,然后可能使用链表解决冲突。
2. 查找效率不同
   链表的查找效率O(n),需要从头节点开始逐个查找。
   哈希表的查找效率O(1),通过哈希函数直接定位到元素位置。
3. 插入和删除效率不同
   链表的插入和删除效率O(1),只需要改变指针方向。
   哈希表的插入和删除效率O(1),需要定位到桶中,然后可能在链表中操作,效率与链表长度相关。
4. 内存利用率不同
   链表的空间是非连续的,会产生一定的空间浪费,内存利用率较低。
   哈希表的空间也是非连续的,内存利用率也比较低,两者差不多。
5. 有无键名不同
   链表的元素只有值,通过指针连接。
   哈希表的元素都有键名和对应的值,通过键名快速查找值。
   综上,二者的主要区别如下:

• 存储结构:链表线性,哈希表非线性
• 查找效率:链表O(n),哈希表O(1)
• 插入和删除效率:链表O(1),哈希表O(1)或O(n)
• 内存利用率:链表和哈希表较低
• 是否有键名:链表无键名,哈希表有键名
  所以,当需要快速查找时,哈希表更加高效。但如果 pursued 插入和删除效率,链表会更好。根据实际场景选择合适的存储结构,能够大幅度提高程序的性能。
  总之,哈希表和链表各有优势,选择哪种结构需要根据具体需求和时间与空间复杂度进行权衡。

哈希表是基础的数据结构

是的,哈希表是一种非常重要和基础的数据结构。它具有以下几个特征:

1. 高效的查询效率O(1)
   通过哈希函数快速定位到元素位置,实现O(1)的查询时间复杂度,这是哈希表的最重要特征。
2. 支持快速的插入和删除
   通过哈希函数直接定位到元素位置,插入和删除的时间复杂度也是O(1),这使得哈希表支持高效的增删查操作。
3. 基于键值对的存储结构
   哈希表内的元素都是键值对,通过键快速获取对应的值,这种映射型的存储结构在许多场景下都很有用。
4. 解决冲突的方法
   哈希表中会出现两个不同的键通过哈希函数映射到同一个位置的冲突情况,需要采用链地址法或开放定址法等方法解决冲突,这也是哈希表的一个重要特征。
5. 自动扩容
   当哈希表中元素过多,冲突增多时,会自动进行扩容操作,以减少冲突提高效率,这能够确保哈希表拥有较为稳定的性能。
   所以,基于上述几点,我们可以得出结论:
   哈希表是一种非常重要和基础的数据结构,它具有O(1)的查询效率,支持快速的增删查操作,基于键值对的存储方式,有解决冲突的方法,并且能够自动扩容以保证效率。
   这使得哈希表在现代算法和应用中有着广泛的使用,是每一位程序员和算法工程师必备的基础知识。理解哈希表的原理和实现,有助于我们设计高性能的程序和算法。
   所以说,哈希表确实是一种基础并且至关重要的数据结构,是我们学习算法和数据结构必须掌握和理解的内容。

举例说明链地址法 java

链地址法是解决哈希冲突的一种方法,它采用链表将哈希值相同的元素连接起来。我们可以通过Java的HashMap来举例说明链地址法。
HashMap中,每个桶都是一个链表,当发生哈希冲突时,将元素添加到链表中,这就是链地址法解决冲突的实现。
例如,我们有一个HashMap,大小为10,装载因子0.75,键 a,b,c 的哈希值都为3。

HashMap<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
1. 我们首先计算a的哈希值,为3,将(a, 1)放入索引为3的桶中。
2. 计算b的哈希值也为3,发生冲突,采用链地址法,将(b, 2)链在(a, 1)后面,形成链表。
3. 计算c的哈希值还是3,继续采用链地址法,将(c, 3)链在(b, 2)后面。
此时的HashMap结构如下:
   0  1  2  3  4  5  6  7  8  9
+---+---+---+---+---+---+---+---+---+---+
|   |   |   | a |   |   |   |   |   |   |  
+---+---+---+---+---+---+---+---+---+---+
|   |   |   | b |   |   |   |   |   |   |   
+---+---+---+---+---+---+---+---+---+---+
|   |   |   | c |   |   |   |   |   |   |    
+---+---+---+---+---+---+---+---+---+---+

可以看出,索引为3的桶形成了一个链表,链表中依次存储着(a, 1),(b, 2)和(c, 3)这3个键值对,这就是链地址法解决冲突的实现过程。
查询任一键值对时,也需要通过链表顺序查找,时间复杂度为O(n),这也是链地址法的缺点。但由于HashMap扩容后,链表长度会重新计算和调整,可以在一定程度上防止链表过长影响效率。
所以,我们可以总结链地址法解决冲突的主要特点为:采用链表将冲突的元素链接起来,查询需要顺序遍历链表,时间复杂度为O(n)。但通过合理的装载因子和扩容机制可以防止效率过低。这是一种简单有效的解决冲突方法,许多哈希表的实现,如Java的HashMap,都是采用这种方法。

讲讲哈希表的应用

哈希表有广泛的应用,主要体现在以下几个方面:

1. 缓存
   哈希表支持快速的查找和插入操作,非常适合用作缓存结构。许多算法和系统都会使用哈希表来实现缓存功能。
   例如,LRU缓存淘汰算法使用哈希表来快速查找缓存项;操作系统使用哈希表来管理内存,实现虚拟内存等。
2. 关联数组
   哈希表中的键值对存储结构就是一种关联数组,可以通过键快速获取值。
   许多语言,如Java和Python都将哈希表作为默认的关联数组来使用,例如Java的HashMap和Python的dict。
3. 集合
   通过赋予哈希表的值类型均为boolean,可以将其实现为集合结构,支持快速的集合操作。
   例如,我们可以定义一个布尔值哈希表,true表示元素在集合中,false表示不在,这样就可以得到一个集合结构,支持O(1)时间复杂度的添加、删除、判断元素是否在集合内等操作。
   许多语言标准库的Set集合都是这样实现的,例如Java的HashSet。
4. 数据库索引
   数据库中的索引通常使用B+树或哈希表来实现,哈希表可以支持快速的查找,因此也经常被用作数据库索引结构的内部实现。
5. 分布式哈希表
   为了扩展到更大的数据量,我们可以将哈希表分布到多台机器上,每个机器维护一部分数据,这种结构就是分布式哈希表。
   它结合了哈希表的优点和分布式的扩展性,被广泛应用于分布式缓存、分布式文件系统元数据管理等场景。
   除此之外,哈希表还被用于鼠标跟踪、词典、密码学、路由缓存等许多领域。
   总之,哈希表是一个非常实用和高效的数据结构,由于具备O(1)时间复杂度的操作和方便的键值对形式,它被广泛应用于缓存、集合、关联数组、数据库索引等诸多场景,是一种重要且实用的基础数据结构。

说说一致性哈希

一致性哈希是一种哈希算法,它可以在不 stops 服务的情况下,动态地向哈希表中增加或删除节点。它通过算法计算,使得大多数的键只需要在少数节点间迁移,从而实现最少的重新分片。
一致性哈希算法有以下主要特征:

1. 哈希环
   一致性哈希算法采用哈希环的结构,将所有的哈希节点放置在这个环上。每个键通过哈希函数映射到这个环上,落在 clock-wise 方向第一个节点上。
2. 虚拟节点
   为了获得更均衡的分布,我们会为每个物理节点创建多个虚拟节点。这些虚拟节点具有相同的哈希值,放置在哈希环上。
3. 重新映射最小
   当添加或删除一个节点时,只会影响与该节点相关的键,大部分键能够保持不变。通过虚拟节点,重新映射的键会分散到多个节点,从而最小化影响。
4. 节点复制
   为了实现高可用,我们会对同一个物理节点创建多个虚拟节点。这样即使某节点下线,它的键仍然能够通过其他虚拟节点得到服务。这实现了节点冗余和故障转移的效果。

一致性哈希算法的实现过程大致如下:

1. 确定哈希环,例如0-232的区间。
2. 为每个节点创建多个虚拟节点,按节点哈希值均匀放置在环上。
3. 确定每个键的哈希值,映射到第一个 clock-wise 的虚拟节点。
4. 当添加或删除节点时,找到新旧节点中的键,重新映射到新放置的虚拟节点上。
5. 保证每个实际节点都有多个虚拟节点,实现高可用。
   一致性哈希算法的优点是动态扩容和缩容时,大部分键都不需要迁移,可以做到最少分片。并且通过虚拟节点可以很好的处理节点下线的情况,实现高可用。这使得一致性哈希算法非常适用于缓存,分布式哈希表等场景,是一种很重要的算法。

举个例子

我们通过一个简单的例子来说明一致性哈希算法。
假设我们有3个节点,节点A,节点B和节点C。并为每个节点创建2个虚拟节点,构建一个哈希环如下:

0     |     55     |     109   |   163    |   217    |   271    |   325
A1         B1              A2         C1         B2      C2

键的哈希值在0-325的区间,映射到第一个clock-wise虚拟节点上。

1. 键K1的哈希值为100,落在区间55-109上,映射到虚拟节点A2,存储在节点A。
2. 键K2的哈希值为260,落在区间217-271上,映射到虚拟节点C2,存储在节点C。 
3. 键K3的哈希值为15,落在区间0-55上,映射到虚拟节点A1,存储在节点A。

现在,我们要添加节点D,并创建2个虚拟节点D1和D2。更新后的哈希环如下:

0     |     55     |     109   |163|   217    |271|   325|379  
A1     B1      A2    D1   C1        B2     D2   C2 

由于添加了节点D,键K1和K3现在应该映射到节点D的虚拟节点上。所以:

1. 键K1的哈希值为100,现在落在区间55-163上,映射到虚拟节点D1,从节点A迁移到节点D。 
2. 键K2的哈希值为260,仍然落在区间271-325上,映射到虚拟节点C2,保持不变。
3. 键K3的哈希值为15,现在落在区间0-55上,映射到虚拟节点D1,从节点A迁移到节点D。 
通过这个例子,我们可以看出:
1. 大多数键都保持映射不变,只有少数键需要迁移,实现最小的重新分片。
2. 键映射到虚拟节点,即使物理节点下线或更换,也能通过其他虚拟节点继续提供服务,实现高可用。
3. 通过为每个节点创建多个虚拟节点,可以较为均衡的分布键,降低热点问题。

这就是一致性哈希算法的基本过程和原理。通过动态调整虚拟节点,实现扩容时最小的数据迁移,这使它非常适用于缓存等场景。