Einige häufig gestellte Fragen zu Redis-Interviews (mit Antworten)

1. Was ist Redis?

Redis ist eine leistungsstarke Schlüsselwertdatenbank, die auf Speicher basiert.

Besondere Empfehlung: Fragen zum Redis-Interview 2020 (aktuell)

2. Eigenschaften von Reids

Redis ist im Wesentlichen eine In-Memory-Datenbank vom Typ Schlüsselwert, ähnlich wie Memcached. Die gesamte Datenbank wird für den Betrieb in den Speicher geladen und die Datenbankdaten werden regelmäßig durch asynchrone Vorgänge zur Speicherung auf die Festplatte geleert. Da es sich um eine reine Speicheroperation handelt, verfügt Redis über eine hervorragende Leistung und kann mehr als 100.000 Lese- und Schreibvorgänge pro Sekunde verarbeiten. Es ist die schnellste bekannte Schlüsselwert-Datenbank.

Die Exzellenz von Redis liegt nicht nur in seiner Leistung, sondern auch darin, dass es das Speichern einer Vielzahl von Datenstrukturen unterstützt, im Gegensatz zu Memcached Redis kann nur 1 MB Daten speichern. Es wird verwendet, um viele nützliche Funktionen zu implementieren, z. B. die Verwendung seiner Liste zum Erstellen einer FIFO-Zwei-Wege-verknüpften Liste zum Implementieren eines leichten und leistungsstarken Nachrichtenwarteschlangendienstes und die Verwendung seines Sets zum Erstellen eines Hochleistungs-Tag-System usw. Darüber hinaus kann Redis auch die Ablaufzeit für den gespeicherten Schlüsselwert festlegen, sodass es auch als erweiterte Version von Memcached verwendet werden kann.

Der Hauptnachteil von Redis besteht darin, dass die Datenbankkapazität durch den physischen Speicher begrenzt ist und nicht zum leistungsstarken Lesen und Schreiben großer Datenmengen verwendet werden kann. Daher sind die für Redis geeigneten Szenarien hauptsächlich auf hohe Leistung beschränkt Operationen und Berechnungen kleinerer Datenmengen.

Redis-Video-Tutorial

　(1) Es ist schnell, weil die Daten im Speicher gespeichert werden, ähnlich wie bei HashMap. Der Vorteil von HashMap besteht darin, dass die zeitliche Komplexität von Suche und Betrieb O(1) ist

(2) Unterstützt umfangreiche Datentypen, unterstützt Zeichenfolgen, Listen, Mengen, sortierte Mengen, Hash

(3) Unterstützt Transaktionen und Operationen sind atomar, die sogenannte Atomizität bedeutet, dass alle Änderungen an den Daten ausgeführt werden oder alle Nicht ausgeführt

(4) Umfangreiche Funktionen: Kann zum Zwischenspeichern, Versenden von Nachrichten und zum Festlegen der Ablaufzeit per Schlüssel verwendet werden, es wird nach Ablauf automatisch gelöscht

　(1) Alle Werte in Memcached sind einfache Zeichenfolgen, und Redis unterstützt als Ersatz umfangreichere Datentypen

(2) Redis ist schneller als Memcached Viel schneller

(3) Redis kann seine Daten beibehalten

1). Speichermethode Memecache speichert alle Daten im Speicher. Nach einem Stromausfall bleibt die Datenmenge hängen. Ein Teil von Redis wird auf der Festplatte gespeichert, was die Datenpersistenz gewährleistet.

2), Datenunterstützungstyp Memcache unterstützt relativ einfache Datentypen. Redis verfügt über komplexe Datentypen.

3). Die zugrunde liegenden Modelle sind unterschiedlich. Ihre zugrunde liegenden Implementierungsmethoden und Anwendungsprotokolle für die Kommunikation mit Clients sind unterschiedlich. Redis hat direkt einen eigenen VM-Mechanismus erstellt, denn wenn das allgemeine System Systemfunktionen aufruft, verschwendet es eine gewisse Zeit für das Verschieben und Anfordern.

1). Wenn der Hauptthread relativ groß ist, ist die Auswirkung auf die Leistung sehr groß und der Dienst wird zeitweise angehalten. Daher ist es am besten, wenn der Master keine Speicher-Snapshots schreibt.

2). Wenn die AOF-Datei nicht neu geschrieben wird, hat diese Persistenzmethode nur minimale Auswirkungen auf die Leistung, aber die AOF-Datei wird weiter wachsen beeinflussen die Wiederherstellung der Master-Neustartgeschwindigkeit. Es ist am besten, keine Persistenzarbeiten auf dem Master durchzuführen, einschließlich Speicher-Snapshots und AOF-Protokolldateien. Aktivieren Sie insbesondere keine Speicher-Snapshots für die Persistenz. Wenn die Daten kritisch sind, sollte ein Slave AOF-Sicherungsdaten aktivieren einmal pro Sekunde zu synchronisieren.

3) Der Master ruft BGREWRITEAOF auf, um die AOF-Datei neu zu schreiben. AOF belegt beim Neuschreiben eine große Menge an CPU- und Speicherressourcen, was zu einer übermäßigen Dienstlast und einer kurzfristigen Dienstunterbrechung führt.

4), Leistungsprobleme bei der Redis-Master-Slave-Replikation. Für die Geschwindigkeit der Master-Slave-Replikation und die Stabilität der Verbindung ist es am besten, wenn sich Slave und Master im selben LAN befinden

volatile-lru: Wählen Sie die zuletzt verwendeten Daten aus dem Datensatz (server.db[i].expires) mit einer für die Eliminierung festgelegten Ablaufzeit aus

allkeys -random: Daten zur Eliminierung willkürlich aus dem Datensatz auswählen (server.db[i].dict)

keine Enviction (Räumung): Es ist verboten, Daten zu verwerfen

8. Bitte verwenden Sie Redis und eine beliebige Sprache, um einen böswilligen Login-Schutzcode zu implementieren und jede Benutzer-ID auf maximal 5 zu beschränken Anmeldungen in 1 Stunde. Für bestimmte Anmeldefunktionen oder Funktionen verwenden Sie einfach eine leere Funktion und müssen diese nicht im Detail aufschreiben.

Verwenden Sie zur Implementierung eine Liste: Jedes Element in der Liste stellt die Anmeldezeit dar. Solange die Differenz zwischen der letzten 5. Anmeldezeit und der aktuellen Zeit nicht mehr als 1 Stunde beträgt, ist die Anmeldung verboten . Der in Python geschriebene Code lautet wie folgt:

9. Warum muss Redis alle Daten im Speicher ablegen? >Redis speichert Daten, um die schnellste Lese- und Schreibgeschwindigkeit zu erreichen. Alle werden asynchron in den Speicher gelesen und auf die Festplatte geschrieben. Redis zeichnet sich also durch hohe Geschwindigkeit und Datenpersistenz aus. Wenn die Daten nicht im Speicher abgelegt werden, beeinträchtigt die E/A-Geschwindigkeit der Festplatte die Leistung von Redis erheblich. Heutzutage, da Speicher immer billiger wird, wird Redis immer beliebter.

10.Redis ist Single-Process und Single-Threaded

Redis nutzt Warteschlangentechnologie, um gleichzeitigen Zugriff in seriellen Zugriff umzuwandeln, wodurch der Overhead der herkömmlichen seriellen Datenbanksteuerung entfällt

11. Wie kann das Problem der Parallelitätskonkurrenz von Redis gelöst werden?

Redis ist ein Einzelprozess-Single-Thread-Modus, der den Warteschlangenmodus verwendet, um gleichzeitigen Zugriff in seriellen Zugriff umzuwandeln . Redis selbst hat kein Sperrkonzept. Wenn der Jedis-Client jedoch gleichzeitig auf Redis zugreift, kann es zu Problemen wie Verbindungs-Timeout, Datenkonvertierungsfehlern und dem Schließen der Verbindung durch den Client kommen werden alle durch Verwirrung bei der Clientverbindung verursacht.

12. CAS (Check-and-Set-Operation zur Implementierung optimistischer Sperren) in Redis verstehen?

Wie viele andere Datenbanken bietet auch Redis einen NoSQL-Datenbanktransaktionsmechanismus . In Redis sind die vier Befehle MULTI/EXEC/DISCARD/WATCH der Eckpfeiler unserer Transaktionsimplementierung.

13.WATCH-Befehl und CAS-basiertes optimistisches Sperren:

In Redis-Transaktionen kann der WATCH-Befehl verwendet werden, um CAS-Funktionalität (Check-and-Set) bereitzustellen . Gehen Sie davon aus, dass wir mehrere Schlüssel über den WATCH-Befehl überwachen, bevor die Transaktion ausgeführt wird. Wenn sich der Wert eines Schlüssels nach WATCH ändert, wird die durch den EXEC-Befehl ausgeführte Transaktion abgebrochen und eine Null-Multi-Bulk-Antwort zurückgegeben, um den Aufrufer zu benachrichtigen der Transaktion.

Ausführung fehlgeschlagen. Wir gehen beispielsweise erneut davon aus, dass der Befehl incr in Redis nicht bereitgestellt wird, um die atomare Inkrementierung von Schlüsselwerten abzuschließen. Wenn wir diese Funktion implementieren möchten, können wir nur den entsprechenden Code selbst schreiben. Der Pseudocode lautet wie folgt:

val = GET mykey
val = val + 1
SET mykey $val

以上代码只有在单连接的情况下才可以保证执行结果是正确的，因为如果在同一时刻有多个客户端在同时执行该段代码，那么就会出现多线程程序中经常出现的一种错误场景--竞态争用(race condition)。

比如，客户端A和B都在同一时刻读取了mykey的原有值，假设该值为10，此后两个客户端又均将该值加一后set回Redis服务器，这样就会导致mykey的结果为11，而不是我们认为的12。为了解决类似的问题，我们需要借助WATCH命令的帮助，见如下代码：

WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC

和此前代码不同的是，新代码在获取mykey的值之前先通过WATCH命令监控了该键，此后又将set命令包围在事务中，这样就可以有效的保证每个连接在执行EXEC之前，如果当前连接获取的mykey的值被其它连接的客户端修改，那么当前连接的EXEC命令将执行失败。这样调用者在判断返回值后就可以获悉val是否被重新设置成功。

14.redis持久化的几种方式

1、快照（snapshots）
缺省情况情况下，Redis把数据快照存放在磁盘上的二进制文件中，文件名为dump.rdb。你可以配置Redis的持久化策略，例如数据集中每N秒钟有超过M次更新，就将数据写入磁盘；或者你可以手工调用命令SAVE或BGSAVE。

工作原理
　． Redis forks.
　． 子进程开始将数据写到临时RDB文件中。
　． 当子进程完成写RDB文件，用新文件替换老文件。
　． 这种方式可以使Redis使用copy-on-write技术。
2、AOF
快照模式并不十分健壮，当系统停止，或者无意中Redis被kill掉，最后写入Redis的数据就会丢失。这对某些应用也许不是大问题，但对于要求高可靠性的应用来说，Redis就不是一个合适的选择。Append-only文件模式是另一种选择。你可以在配置文件中打开AOF模式。

3、虚拟内存方式

当你的key很小而value很大时,使用VM的效果会比较好.因为这样节约的内存比较大.

当你的key不小时,可以考虑使用一些非常方法将很大的key变成很大的value,比如你可以考虑将key,value组合成一个新的value.

vm-max-threads这个参数,可以设置访问swap文件的线程数,设置最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的.可能会造成比较长时间的延迟,但是对数据完整性有很好的保证.

自己测试的时候发现用虚拟内存性能也不错。如果数据量很大，可以考虑分布式或者其他数据库

15.redis的缓存失效策略和主键失效机制

作为缓存系统都要定期清理无效数据，就需要一个主键失效和淘汰策略.

在Redis当中，有生存期的key被称为volatile。在创建缓存时，要为给定的key设置生存期，当key过期的时候（生存期为0），它可能会被删除。

1、影响生存时间的一些操作

生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆盖原来的数据，也就是说，修改key对应的value和使用另外相同的key和value来覆盖以后，当前数据的生存时间不同。

比如说，对一个 key 执行INCR命令，对一个列表进行LPUSH命令，或者对一个哈希表执行HSET命令，这类操作都不会修改 key 本身的生存时间。另一方面，如果使用RENAME对一个 key 进行改名，那么改名后的 key的生存时间和改名前一样。

RENAME命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。使用PERSIST命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个persistent key 。

2、如何更新生存时间

可以对一个已经带有生存时间的 key 执行EXPIRE命令，新指定的生存时间会取代旧的生存时间。过期时间的精度已经被控制在1ms之内，主键失效的时间复杂度是O（1），EXPIRE和TTL命令搭配使用，TTL可以查看key的当前生存时间。设置成功返回 1；当 key 不存在或者不能为 key 设置生存时间时，返回 0 。

最大缓存配置

在 redis 中，允许用户设置最大使用内存大小

server.maxmemory

默认为0，没有指定最大缓存，如果有新的数据添加，超过最大内存，则会使redis崩溃，所以一定要设置。redis 内存数据集大小上升到一定大小的时候，就会实行数据淘汰策略。

redis 提供 6种数据淘汰策略：

　． volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

　． volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰

　． volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰

　． allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰

　． allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰

　． no-enviction（驱逐）：禁止驱逐数据

注意这里的6种机制，volatile和allkeys规定了是对已设置过期时间的数据集淘汰数据还是从全部数据集淘汰数据，后面的lru、ttl以及random是三种不同的淘汰策略，再加上一种no-enviction永不回收的策略。

使用策略规则：

1、如果数据呈现幂律分布，也就是一部分数据访问频率高，一部分数据访问频率低，则使用allkeys-lru

2、如果数据呈现平等分布，也就是所有的数据访问频率都相同，则使用allkeys-random

三种数据淘汰策略：

ttl和random比较容易理解，实现也会比较简单。主要是Lru最近最少使用淘汰策略，设计上会对key 按失效时间排序，然后取最先失效的key进行淘汰

16.redis 最适合的场景　　

Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差别，那么可能大家就会有疑问，似乎Redis更像一个加强版的Memcached，那么何时使用Memcached,何时使用Redis呢?

如果简单地比较Redis与Memcached的区别，大多数都会得到以下观点：

1 、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

2 、Redis支持数据的备份，即master-slave模式的数据备份。

3 、Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。

（1）、会话缓存（Session Cache）

最常用的一种使用Redis的情景是会话缓存（session cache）。用Redis缓存会话比其他存储（如Memcached）的优势在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，如果用户的购物车信息全部丢失，大部分人都会不高兴的，现在，

他们还会这样吗？

幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

（2）、全页缓存（FPC）

除基本的会话token之外，Redis还提供很简便的FPC平台。回到一致性问题，即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，这是一个极大改进，类似PHP本地FPC。

再次以Magento为例，Magento提供一个插件来使用Redis作为全页缓存后端。

此外，对WordPress的用户来说，Pantheon有一个非常好的插件 wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。
（3）、队列

Reids在内存存储引擎领域的一大优点是提供 list 和 set 操作，这使得Redis能作为一个很好的消息队列平台来使用。Redis作为队列使用的操作，就类似于本地程序语言（如Python）对 list 的 push/pop 操作。

如果你快速的在Google中搜索“Redis queues”，你马上就能找到大量的开源项目，这些项目的目的就是利用Redis创建非常好的后端工具，以满足各种队列需求。例如，Celery有一个后台就是使用Redis作为broker，你可以从这里去查看。

（4），排行榜/计数器

Redis在内存中对数字进行递增或递减的操作实现的非常好。集合（Set）和有序集合（Sorted Set）也使得我们在执行这些操作的时候变的非常简单，Redis只是正好提供了这两种数据结构。所以，我们要从排序集合中获取到排名最靠前的10个用户–我们称之为“user_scores”，我们只需要像下面一样执行即可：

当然，这是假定你是根据你用户的分数做递增的排序。如果你想返回用户及用户的分数，你需要这样执行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一个很好的例子，用Ruby实现的，它的排行榜就是使用Redis来存储数据的，你可以在这里看到。

（5）、发布/订阅

Last (aber sicherlich nicht zuletzt) ​​ist die Publish/Subscribe-Funktionalität von Redis. Es gibt tatsächlich viele Anwendungsfälle für Publish/Subscribe. Ich habe gesehen, wie Leute es in sozialen Netzwerkverbindungen, als Auslöser für Veröffentlichungs-/Abonnement-basierte Skripte und sogar zum Aufbau von Chat-Systemen mithilfe der Veröffentlichungs-/Abonnementfunktionalität von Redis verwenden! (Nein, das stimmt, Sie können es nachschauen).

Von allen von Redis bereitgestellten Funktionen ist diese meiner Meinung nach diejenige, die den Leuten am wenigsten gefällt, obwohl sie den Benutzern diese Multifunktion bietet.

Empfohlen: Redis-Einführungs-Tutorial

Das obige ist der detaillierte Inhalt vonEinige häufig gestellte Fragen zu Redis-Interviews (mit Antworten). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!