关于：Redis 的内存回收策略、Key 失效机制 - 版本历史

Eijux：/* Key 失效机制 */

2021-05-11T18:03:02Z

Key 失效机制

←上一版本		2021年5月12日 (三) 02:03的版本
第130行：		第130行：

	== '''Key 失效机制''' ==		== '''Key 失效机制''' ==
	Key 的失效机制，就是'''如何清除带有过期时间的 key'''。		Key 的失效机制，就是'''如何清除带有过期时间的 key'''。【缓存更新】

Eijux：/* “近似 LRU”（随机采样 LRU） */

2021-05-11T09:57:23Z

“近似 LRU”（随机采样 LRU）

←上一版本		2021年5月11日 (二) 17:57的版本
第67行：		第67行：
	# 继续执行命令。		# 继续执行命令。

	==~~“近似 LRU”（随机采样~~ LRU）==		==“'''近似 LRU'''”（随机采样 LRU）==
	<pre>		<pre>
	Redis 中的 LRU 算法不是精确的 LRU 算法，而是一种近似的 LRU 算法（经过采样的 LRU）。		Redis 中的 LRU 算法不是精确的 LRU 算法，而是一种近似的 LRU 算法（经过采样的 LRU）。

Eijux：/* Key 的失效机制 */

2021-05-11T09:57:08Z

Key 的失效机制

←上一版本		2021年5月11日 (二) 17:57的版本
第129行：		第129行：
	: 如果使用 '''LFU''' 算法则不会出现这种情况，因为：使用一次并不会使一个 key 成为热点数据。		: 如果使用 '''LFU''' 算法则不会出现这种情况，因为：使用一次并不会使一个 key 成为热点数据。

	== Key ~~的失效机制~~ ==		== '''Key 失效机制''' ==
	Key 的失效机制，就是'''如何清除带有过期时间的 key'''。		Key 的失效机制，就是'''如何清除带有过期时间的 key'''。

Eijux：/* 内存过期策略 */

2021-05-11T09:56:38Z

内存过期策略

←上一版本		2021年5月11日 (二) 17:56的版本
第24行：		第24行：
	</syntaxhighlight>		</syntaxhighlight>

	== ~~内存过期策略~~ ==		== '''内存回收策略''' ==
	Redis ~~提供了多种内存过期策略：~~		Redis 提供了多种内存回收策略：
	# “'''volatile-lru'''”：在“所有带有过期时间的 key”中使用 '''LRU''' 算法淘汰数据；【带有过期时间的 key】		# “'''volatile-lru'''”：在“所有带有过期时间的 key”中使用 '''LRU''' 算法淘汰数据；【带有过期时间的 key】
	# “'''volatile-random'''”：在“所有带有过期时间的 key”中'''随机'''淘汰数据；【带有过期时间的 key】		# “'''volatile-random'''”：在“所有带有过期时间的 key”中'''随机'''淘汰数据；【带有过期时间的 key】

Eijux：Eijux移动页面关于：Redis 的内存回收策略、Key 过期策略至关于：Redis 的内存回收策略、Key 失效机制，不留重定向

2021-05-11T09:55:56Z

Eijux移动页面关于：Redis 的内存回收策略、Key 过期策略至关于：Redis 的内存回收策略、Key 失效机制，不留重定向

←上一版本	2021年5月11日 (二) 17:55的版本
（没有差异）

Eijux：/* Key 的过期策略 */

2021-05-11T09:55:30Z

Key 的过期策略

←上一版本		2021年5月11日 (二) 17:55的版本
第129行：		第129行：
	: 如果使用 '''LFU''' 算法则不会出现这种情况，因为：使用一次并不会使一个 key 成为热点数据。		: 如果使用 '''LFU''' 算法则不会出现这种情况，因为：使用一次并不会使一个 key 成为热点数据。

	== Key ~~的过期策略~~ ==		== Key 的失效机制 ==
	Key ~~的过期策略，~~'''~~就是带有过期时间的~~ key'''。		Key 的失效机制，就是'''如何清除带有过期时间的 key'''。

	~~=== 设置带有过期时间的 key ===~~
	~~示例：~~
	~~: 通过“redis> set name ziyouu ex 100”命令，在 Redis 中设置一个 key 为 name，值为 ziyouu 的数据。~~
	~~: [[File:Redis：设置带有过期时间的 key.png\|600px]]~~
	~~从上面的截图中我们可以看到右下角有个 '''TTL'''，并且每次刷新都是在减少的，说明我们设置带有过期时间的 key 成功了。~~

	~~===~~ Redis ~~如何清除带有过期时间的 key ===~~		Redis 有两种“Key 失效机制”：
	~~Redis 清除带有过期时间的 key，有两种方式：~~
	# '''惰性策略'''（被动方式）：在每次访问的时候判断该 key 是否到达过期时间了，过期了就删除掉。		# '''惰性策略'''（被动方式）：在每次访问的时候判断该 key 是否到达过期时间了，过期了就删除掉。
	#* 对内存不太友好；对 CPU 友好；		#* 对内存不太友好；对 CPU 友好；
第147行：		第141行：


	Redis ~~服务器在真正实现的时候上面的~~'''~~两种方式都会用到~~'''~~，这样就可以得到一种折中的方式。~~		Redis 在实现的时候，会将以上两种方式'''结合使用'''：


	~~另外在定时策略中，从官网我们可以看到如下说明：~~
	<pre>		<pre>
	Specifically this is what Redis does 10 times per second:		Specifically this is what Redis does 10 times per second:
第158行：		第149行：
	3、If more than 25% of keys were expired, start again from step 1.		3、If more than 25% of keys were expired, start again from step 1.
	</pre>		</pre>
	即：Redis ~~会在有过期时间的~~ Key 集合中随机 20 个出来，删掉已经过期的 ~~Key，如果比例超过~~ 25%~~，再重新执行操作。每秒中会执行~~ 10 个这样的操作。		即：Redis 会'''在有过期时间的 Key 集合中随机 20 个出来，删掉已经过期的 Key；如果过期比例仍超过 25%，重新执行此操作'''。
			* 每秒中会执行 10 个这样的操作。

			=== 设置带有过期时间的 key ===
			示例：
			: 通过“redis> set name ziyouu ex 100”命令，在 Redis 中设置一个 key 为 name，值为 ziyouu 的数据。
			: [[File:Redis：设置带有过期时间的 key.png\|600px]]
			从上面的截图中我们可以看到右下角有个 '''TTL'''，并且每次刷新都是在减少的，说明我们设置带有过期时间的 key 成功了。

Eijux：/* Redis 如何清除带有过期时间的 key */

2021-05-11T09:48:44Z

Redis 如何清除带有过期时间的 key

←上一版本		2021年5月11日 (二) 17:48的版本
第140行：		第140行：
	=== Redis 如何清除带有过期时间的 key ===		=== Redis 如何清除带有过期时间的 key ===
	Redis 清除带有过期时间的 key，有两种方式：		Redis 清除带有过期时间的 key，有两种方式：
	~~# '''定时策略'''：给每个 key 加一个定时器，这样当时间到达过期时间的时候就自动删除 key。~~		# '''惰性策略'''（被动方式）：在每次访问的时候判断该 key 是否到达过期时间了，过期了就删除掉。
	~~#* 对内存友好（因为可以及时清理过期的 key）；但对 CPU 不友好（每个带有过期时间的 key 都需要一个定时器，会占用很多的 CPU）；~~
	~~#* 主动清理。~~
	# '''惰性策略'''~~：在每次访问一个 key 的时候再去判断这个~~ key 是否到达过期时间了，过期了就删除掉。
	#* 对内存不太友好；对 CPU 友好；		#* 对内存不太友好；对 CPU 友好；
	~~#* 被动清理。~~
	#* 但是存在一个问题：如果这些过期的 key 我们再也不会访问，那么永远就不会删除了。		#* 但是存在一个问题：如果这些过期的 key 我们再也不会访问，那么永远就不会删除了。
			# '''定时策略'''（主动方式）：随机抽取一部分的 key 进行校验，如果已经失效，就删除淘汰。
			#* 对内存友好（因为可以及时清理过期的 key）；但对 CPU 不友好（每个带有过期时间的 key 都需要一个定时器，会占用很多的 CPU）；

Eijux：/* 内存过期策略 */

2021-05-11T09:44:44Z

内存过期策略

←上一版本		2021年5月11日 (二) 17:44的版本
第26行：		第26行：
	== 内存过期策略 ==		== 内存过期策略 ==
	Redis 提供了多种内存过期策略：		Redis 提供了多种内存过期策略：
	# “'''volatile-lru'''”：在“所有带有过期时间的 key”中使用 '''LRU''' 算法淘汰数据；【带有过期时间的 ~~key，LRU】~~		# “'''volatile-lru'''”：在“所有带有过期时间的 key”中使用 '''LRU''' 算法淘汰数据；【带有过期时间的 key】
	# “'''volatile-random'''”：在“所有带有过期时间的 key”中'''随机'''淘汰数据；【带有过期时间的 ~~key，随机】~~		# “'''volatile-random'''”：在“所有带有过期时间的 key”中'''随机'''淘汰数据；【带有过期时间的 key】
	# “'''volatile-ttl'''”：在“所有带有过期时间的 key”中，淘汰会'''最早过期'''的数据；【带有过期时间的 ~~key，最早过期】~~		# “'''volatile-ttl'''”：在“所有带有过期时间的 key”中，淘汰会'''最早过期'''的数据；【带有过期时间的 key】
	# “'''alkeys-lru'''”：在“所有的 key”中使用 '''LRU''' ~~算法淘汰数据；【所有key，LRU】~~		# “'''alkeys-lru'''”：在“所有的 key”中使用 '''LRU''' 算法淘汰数据；【所有key】
	# “'''allkeys-random'''”：在“所有的 key”中'''随机'''~~淘汰数据；【所有key，随机】~~		# “'''allkeys-random'''”：在“所有的 key”中'''随机'''淘汰数据；【所有key】
	# “'''noeviction'''”：'''不回收'''~~，当达到最大内存的时候，在增加新数据的时候会返回 error，不会清除旧数据；【不淘汰】【默认策略】~~		# “'''noeviction'''”：'''不回收'''，不会清除旧数据；
			#* 达到最大内存时，对于写请求不再提供服务，直接返回错误。（DEL请求和部分特殊请求除外）

	* LRU：“Least Recently Used”，即“最近最少使用”。		* LRU：“Least Recently Used”，即“最近最少使用”。
第37行：		第38行：

	=== 配置 ===		=== 配置 ===
	~~在配置文件中我们使用“'''maxmemory-policy'''”来配置策略：~~		同样可以通过两种方式修改内存回收策略：
	: [[File:Redis：配置文件设置内存过期策略.png\|600px]]		# 配置文件：
			#: [[File:Redis：配置文件设置内存过期策略.png\|600px]]
			#: <syntaxhighlight lang="java" highlight="">
			maxmemory-policy allkeys-lru
			</syntaxhighlight>
			# 命令：
			#: <syntaxhighlight lang="java" highlight="">
			// 获取内存淘汰策略可以看到默认是noeviction
			config get maxmemory-policy
			1) "maxmemory-policy"
			2) "noeviction"

			// 修改内存驱逐策略
			config set maxmemory-policy allkeys-lru
			</syntaxhighlight>


第49行：		第64行：
	过期策略按照以下步骤执行：		过期策略按照以下步骤执行：
	# 客户端运行命令，添加数据申请内存；		# 客户端运行命令，添加数据申请内存；
	# Redis ~~检查内存的使用情况，如果已经超过的最大限制，就是根据配置的内存淘汰策略去淘汰相应的 key，从而保证新数据正常添加；~~		# Redis 检查内存的使用情况：如果超过最大限制，则执行内存淘汰策略；
	# 继续执行命令。		# 继续执行命令。

	==~~= 近似的 LRU 算法 =~~==		==“近似 LRU”（随机采样 LRU）==
	Redis 中的 LRU 算法不是精确的 LRU ~~算法，而是一种经过采样的 LRU。~~		<pre>
	~~: 我们可以通过在配置文件中设置“maxmemory-samples 5”来设置采样的大小（默认值为 5，可以自行调整）。~~		Redis 中的 LRU 算法不是精确的 LRU 算法，而是一种近似的 LRU 算法（经过采样的 LRU）。
			</pre>

			近似 LRU 算法通过'''随机采样法'''淘汰数据：'''每次随机出5（默认）个 key，从里面淘汰掉最近最少使用的 key'''。
			* 可以通过在配置文件中设置“'''maxmemory-samples 5'''”来设置采样的大小（默认值为 5，可以自行调整）。
			* Redis 为了实现近似 LRU 算法，给每个 key 增加了一个额外增加了一个 24 bit 的字段，用来存储该 key 最后一次被访问的时间。【？？？】

	~~官方提供的采用对比如下，我们可以看到当采用数设置为 10 的时候已经很接近真实的~~ LRU ~~算法了。~~
			官方提供的采用对比如下，我们可以看到


			=== Redis 3.0 对近似 LRU 算法的优化 ===
			在 Redis 3.x 以上的版本的中做过优化，目前的近似 LRU 算法以及提升了很大的效率。


			新算法会维护一个'''候选池'''（大小为16），池中的数据根据访问时间进行排序：
			# 第一次随机选取的 key 都会放入池中，随后每次随机选取的 key 只有在'''访问时间小于池中最小的时间'''才会放入池中，直到候选池被放满；
			# 当放满后，如果有新的 key 需要放入，则将池中最后访问时间最大（最近被访问）的移除。

			=== 新旧算法的对比 ===
			Redis官方文档给出的新旧算法对比结果：
	: [[File:Redis：“近似的 LRU 算法”采样对比.png\|600px]]		: [[File:Redis：“近似的 LRU 算法”采样对比.png\|600px]]
			其中：
			* 浅灰色是被淘汰的数据
			* 灰色是没有被淘汰掉的老数据
			* 绿色是新加入的数据

			从上图，可以看出：3.0 的效果明显比 2.8 的要得多，并且，取样数越大，越接近标准的 LRU 算法。

			=== Redis 为什么不使用真正的 LRU ===
			Redis 之所以不采样实际的 LRU 算法，是因为会'''耗费很多的内存'''（每个 key 还需要保存前后 key 的地址）。

			== '''LFU'''：新的回收策略 ==
			LFU（“Least Frequently Used”）算法，核心思想是根据 key 的'''最近被访问的频率'''进行淘汰：很少被访问的优先被淘汰，被访问的多的则被留下来。
			* Redis4.0 里面新加的一种淘汰策略。

	~~在 Redis 3.x 以上的版本的中做过优化，目前的近似 LRU 算法以及提升了很大的效率，Redis 之所以不采样实际的 LRU 算法，是因为会~~'''~~耗费很多的内存~~'''：
	<~~pre~~>		LFU 实现主要依靠于两个参数：
	~~The reason why Redis does not use a true LRU implementation is because it costs more memory.~~		# '''计算器'''：计算器取值范围为 0-255，访问次数越高对应的取值越高；
	</~~pre~~>		# '''衰减周期'''：表示每过一定的时间，就对计算器进行减值。

			有如下两个参数：
			<syntaxhighlight lang="java" highlight="">
			// 因子越大，改要使频率计数器所需的次数越多？？？
			lfu-log-factor 10
			// 每隔1分钟计算器减 1；如果是 0 的话表示每次扫描时总是使计数器衰减
			lfu-decay-time 1
			</syntaxhighlight>

			=== LFU 提供的两种回收策略 ===
			# '''volatile-lfu'''：在“设置了过期时间的 key”中使用 LFU 算法淘汰key；
			# '''allkeys-lfu'''：在“所有的 key”中使用 LFU 算法淘汰数据；

			=== LFU 与 LRU ===
			LFU 算法能更好的表示一个 key 被访问的'''热度'''。


			'''LRU''' 可能出现的问题：一个 key 很久没有被访问到，只刚刚是偶尔被访问了一次，那么它就被认为是热点数据，不会被淘汰，而有些 key 将来是很有可能被访问到的则被淘汰了。
			: 如果使用 '''LFU''' 算法则不会出现这种情况，因为：使用一次并不会使一个 key 成为热点数据。

	== Key 的过期策略 ==		== Key 的过期策略 ==

Eijux：/* Redis 内存设置 */

2021-05-11T09:13:02Z

Redis 内存设置

@@ 第8行： / 第8行： @@
 # 只需要在配置文件“redis.conf”中配置一行“'''maxmemory xxx'''”即可，
 #: [[File:Redis：配置文件设置内存大小.png|800px]]
 # 或者我们通过“config set”命令在运行时动态配置 Redis 的内存大小。
 == 内存过期策略 ==

Eijux：/* 内存过期策略 */

2021-05-11T09:10:41Z

内存过期策略

←上一版本		2021年5月11日 (二) 17:10的版本
第12行：		第12行：
	== 内存过期策略 ==		== 内存过期策略 ==
	Redis 提供了多种内存过期策略：		Redis 提供了多种内存过期策略：
	# “'''volatile-lru'''~~”：在所有带有过期时间的 key 中使用~~ '''LRU''' ~~算法淘汰数据；~~		# “'''volatile-lru'''”：在“所有带有过期时间的 key”中使用 '''LRU''' 算法淘汰数据；【带有过期时间的 key，LRU】
	# “'''~~alkeys~~-~~lru~~'''~~”：在所有的 key 中使用最近最少被使用~~ '''~~LRU~~''' ~~算法淘汰数据，保证新加入的数据正常；~~		# “'''volatile-random'''”：在“所有带有过期时间的 key”中'''随机'''淘汰数据；【带有过期时间的 key，随机】
	# “'''volatile-~~random~~'''~~”：在所有带有过期时间的 key 中~~'''随机'''~~淘汰数据；~~		# “'''volatile-ttl'''”：在“所有带有过期时间的 key”中，淘汰会'''最早过期'''的数据；【带有过期时间的 key，最早过期】
	# “'''~~allkeys~~-~~random~~'''~~”：在所有的 key 中~~'''随机'''~~淘汰数据；~~		# “'''alkeys-lru'''”：在“所有的 key”中使用 '''LRU''' 算法淘汰数据；【所有key，LRU】
	# “'''~~volatile~~-~~ttl~~'''~~”：在所有带有过期时间的 key 中，淘汰会~~'''~~最早过期~~'''~~的数据；~~		# “'''allkeys-random'''”：在“所有的 key”中'''随机'''淘汰数据；【所有key，随机】
	# “'''noeviction'''”：'''不回收'''，当达到最大内存的时候，在增加新数据的时候会返回 ~~error，不会清除旧数据；【默认策略】~~		# “'''noeviction'''”：'''不回收'''，当达到最大内存的时候，在增加新数据的时候会返回 error，不会清除旧数据；【不淘汰】【默认策略】

	* LRU：“Least Recently Used”，即“最近最少使用”。		* LRU：“Least Recently Used”，即“最近最少使用”。

关于：Redis 的内存回收策略、Key 失效机制 - 版本历史

Eijux：​/* Key 失效机制 */

Eijux：​/* “近似 LRU”（随机采样 LRU） */

Eijux：​/* Key 的失效机制 */

Eijux：​/* 内存过期策略 */

Eijux：​Eijux移动页面关于：Redis 的内存回收策略、Key 过期策略至关于：Redis 的内存回收策略、Key 失效机制，不留重定向

Eijux：​/* Key 的过期策略 */

Eijux：​/* Redis 如何清除带有过期时间的 key */

Eijux：​/* 内存过期策略 */

Eijux：​/* Redis 内存设置 */

Eijux：​/* 内存过期策略 */

Eijux：/* Key 失效机制 */

Eijux：/* “近似 LRU”（随机采样 LRU） */

Eijux：/* Key 的失效机制 */

Eijux：/* 内存过期策略 */

Eijux：Eijux移动页面关于：Redis 的内存回收策略、Key 过期策略至关于：Redis 的内存回收策略、Key 失效机制，不留重定向

Eijux：/* Key 的过期策略 */

Eijux：/* Redis 如何清除带有过期时间的 key */

Eijux：/* 内存过期策略 */

Eijux：/* Redis 内存设置 */

Eijux：/* 内存过期策略 */