Zusammenfassung der Redis-Interviewfragen, lassen Sie uns mehr darüber erfahren-Schlagzeilen-php.cn

Es ist wieder die Hochphase der Personalbeschaffung und des Job-Hoppings. Sind alle Programmierer nicht in der Lage, den Gedanken zu ertragen, Code einzugeben und sich auf eine Gehaltserhöhung einzulassen? Heute fasse ich die Redis-Interviewfragen für Sie zusammen!

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

Zusammenfassung der Redis-Interviewfragen, lassen Sie uns mehr darüber erfahren

1 redis?

Redis ist eine speicherbasierte Hochleistungs-Schlüsselwertdatenbank. (Empfehlung 1: Redis-Video-Tutorial) (Empfehlung 2: MySQL-Tutorial)

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 zum Implementieren vieler nützlicher Funktionen verwendet, z. B. zum Erstellen einer doppelt verknüpften FIFO-Liste mit seiner Liste, zum Implementieren eines leichten, leistungsstarken Nachrichtenwarteschlangendienstes und zum Erstellen eines Hochleistungs-Nachrichtenwarteschlangendienstes mit seinem Set 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.

3. Welche Vorteile bietet die Verwendung von Redis? 　

(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 String, Liste, Menge, sortierte Menge, Hash

(3) Unterstützt Transaktionen, Operationen sind atomar. Die sogenannte Atomizität bedeutet, dass alle Änderungen an den Daten entweder sind ausgeführt oder nicht. 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

4. Was sind die Vorteile von Redis im Vergleich zu Memcached Advantage? 　

(1) Alle Werte in Memcached sind einfache Zeichenfolgen. Als Ersatz unterstützt Redis umfangreichere Datentypen

(2) Redis ist schneller als Memcached Viel schneller (3) Redis kann seine Daten beibehalten

5 Was sind die Unterschiede zwischen Memcache und Redis?

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ützungstypen 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.

6.Redis häufige Leistungsprobleme und Lösungen: 　

1).Master schreibt einen Speicher-Snapshot und der Speicherbefehl plant die rdbSave-Funktion, die die Arbeit blockiert Wenn der Snapshot relativ groß ist, hat dies große Auswirkungen auf die Leistung 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. Während des Neuschreibens belegt AOF eine große Menge an CPU- und Speicherressourcen, was zu einer übermäßigen Dienstlast und einer kurzfristigen Dienstunterbrechung führt.

4). Leistungsprobleme der Redis-Master-Slave-Replikation und die Stabilität der Verbindung, wenn sich Slave und Master im selben LAN befinden

7. Es gibt 20 Millionen Daten in MySQL, aber nur 200.000 Daten werden in Redis gespeichert.

Zugehöriges Wissen: Wenn die Größe Wenn der Redis-Speicherdatensatz eine bestimmte Größe erreicht, wird eine Datenveralterungsstrategie (Recyclingstrategie) implementiert. redis bietet 6 Dateneliminierungsstrategien:

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

volatile-ttl: Wählen Sie die Daten aus, die aus dem Datensatz (server.db[i].expires) ablaufen, der eine Ablaufzeit zum Eliminieren von

festgelegt hat

volatile-random: Wählen Sie zufällig Daten aus, die aus dem Datensatz (server.db[i].expires) entfernt werden sollen, mit festgelegter Ablaufzeit

allkeys-lru: Aus dem Datensatz (server.db[i ] .dict) und eliminieren Sie die zuletzt verwendeten Daten

allkeys-random: Wählen Sie Daten willkürlich aus dem Datensatz aus (server.db[i].dict), um

no-enviction ( Räumung): Es ist verboten, Daten zu entfernen

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

9. Warum muss Redis alle Daten in den Speicher legen?

Um die schnellste Lese- und Schreibgeschwindigkeit zu erreichen, liest Redis alle Daten ein Speicher und schreibt Daten asynchron auf die Festplatte. 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.

Wenn der maximal verwendete Speicher eingestellt ist, können keine neuen Werte eingefügt werden, nachdem die Anzahl der Datensätze das Speicherlimit erreicht hat.

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

aufgrund einer Client-Verbindungsverwirrung verursacht. Hierfür gibt es zwei Lösungen:

1. Um eine normale und ordnungsgemäße Kommunikation mit Redis zwischen den einzelnen Clients sicherzustellen, werden die Verbindungen gebündelt und gleichzeitig liest und schreibt der Client Redis-Vorgänge werden synchronisiert.

2. Aus Serversicht verwenden Sie setnx, um das Sperren zu implementieren.

Hinweis: Für den ersten Typ muss die Anwendung die Ressourcensynchronisierung selbst durchführen. Die verwendete Methode ist relativ beliebt. Für den zweiten Typ ist die Verwendung von Redis erforderlich setnx-Befehl, erfordert jedoch einige Probleme.

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. Ich glaube, dass dieses Konzept Entwicklern mit Erfahrung in der relationalen Datenbankentwicklung nicht unbekannt ist. Dennoch werden wir die Implementierungsmerkmale von Transaktionen in Redis kurz auflisten:

1). Während der Ausführung der Transaktion stellt Redis keine Dienste für andere Clientanforderungen bereit und stellt so sicher, dass alle Befehle in der Transaktion atomar ausgeführt werden.

2) Im Vergleich zu Transaktionen in relationalen Datenbanken werden nachfolgende Befehle weiterhin ausgeführt, wenn in einer Redis-Transaktion ein Befehl fehlschlägt.

3). Wir können eine Transaktion über den MULTI-Befehl starten, den Personen mit Erfahrung in der relationalen Datenbankentwicklung als „BEGIN TRANSACTION“-Anweisung verstehen können. Die nach dieser Anweisung ausgeführten Befehle werden als Vorgänge innerhalb der Transaktion betrachtet. Schließlich können wir alle Vorgänge innerhalb der Transaktion festschreiben/zurücksetzen, indem wir den Befehl EXEC/DISCARD ausführen. Diese beiden Redis-Befehle können als Äquivalent zur COMMIT/ROLLBACK-Anweisung in einer relationalen Datenbank angesehen werden.

4). Wenn vor dem Start der Transaktion ein Kommunikationsfehler zwischen dem Client und dem Server auftritt und die Netzwerkverbindung unterbrochen wird, werden alle nachfolgend auszuführenden Anweisungen nicht vom Server ausgeführt. Wenn jedoch das Netzwerkunterbrechungsereignis auftritt, nachdem der Client den EXEC-Befehl ausgeführt hat, werden alle Befehle in der Transaktion vom Server ausgeführt.

5). Bei Verwendung des Append-Only-Modus schreibt Redis in diesem Aufruf alle Schreibvorgänge in der Transaktion auf die Festplatte, indem es die Systemfunktion write aufruft. Kommt es jedoch während des Schreibvorgangs zu einem Systemabsturz, beispielsweise bei einem Ausfall durch einen Stromausfall, kann es sein, dass zu diesem Zeitpunkt nur ein Teil der Daten auf die Festplatte geschrieben wird, während ein anderer Teil der Daten verloren geht.

Der Redis-Server führt beim Neustart eine Reihe notwendiger Konsistenzprüfungen durch. Sobald ein ähnliches Problem gefunden wird, wird er sofort beendet und gibt eine entsprechende Fehlermeldung aus. Zu diesem Zeitpunkt müssen wir das im Redis-Toolkit bereitgestellte Tool redis-check-aof vollständig nutzen. Dieses Tool kann uns dabei helfen, Dateninkonsistenzfehler zu lokalisieren und einige der geschriebenen Daten zurückzusetzen. Nach der Reparatur können wir den Redis-Server erneut neu starten.

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

Nach dem Login kopieren

Der obige Code kann nur garantieren, dass das Ausführungsergebnis bei einer einzelnen Verbindung korrekt ist, denn wenn mehrere Clients diesen Code gleichzeitig ausführen, dann ist An Fehlerszenario, das häufig in Multithread-Programmen auftritt – Race Condition (Rennbedingung) tritt auf. Beispielsweise lesen beide Clients A und B gleichzeitig den ursprünglichen Wert von mykey. Danach addieren beide Clients eins zum Wert und setzen ihn auf den Redis-Server zurück von mykey geht verloren. Das Ergebnis ist 11, nicht 12, wie wir dachten. Um ähnliche Probleme zu lösen, benötigen wir die Hilfe des WATCH-Befehls, siehe folgenden Code:

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

Nach dem Login kopieren

Der Unterschied zum vorherigen Code besteht darin, dass der neue Code den Schlüssel durch den WATCH-Befehl überwacht, bevor er den Wert erhält von mykey und dann Der Set-Befehl ist auch von einer Transaktion umgeben, die effektiv sicherstellen kann, dass vor jeder Verbindung EXEC ausgeführt wird, wenn der von der aktuellen Verbindung erhaltene Wert von mykey von anderen verbundenen Clients geändert wird, der EXEC-Befehl der aktuellen Verbindung wird nicht ausgeführt. Auf diese Weise kann der Anrufer nach Beurteilung des Rückgabewerts feststellen, ob val erfolgreich zurückgesetzt wurde.

14. Mehrere Arten der Redis-Persistenz

1. Snapshots

Standardmäßig speichert Redis Daten-Snapshots in der Binärdatei auf der Festplatte Der Name ist dump.rdb. Sie können die Persistenzstrategie von Redis konfigurieren. Wenn der Datensatz beispielsweise alle N Sekunden mehr als M aktualisiert, werden die Daten auf die Festplatte geschrieben, oder Sie können den Befehl SAVE oder BGSAVE manuell aufrufen.

Funktionsprinzip

． Redis-Gabeln.

． Der untergeordnete Prozess beginnt, Daten in die temporäre RDB-Datei zu schreiben.

． Wenn der untergeordnete Prozess mit dem Schreiben der RDB-Datei fertig ist, ersetzen Sie die alte Datei durch die neue Datei.

. Mit dieser Methode kann Redis die Copy-on-Write-Technologie verwenden.

2. AOF

Der Snapshot-Modus ist nicht sehr robust. Wenn das System stoppt oder Redis versehentlich getötet wird, gehen die zuletzt auf Redis geschriebenen Daten verloren. Für einige Anwendungen stellt dies möglicherweise kein großes Problem dar, aber für Anwendungen, die eine hohe Zuverlässigkeit erfordern, ist

Redis keine geeignete Wahl.

Der Modus „Nur Datei anhängen“ ist eine weitere Option.

Sie können den AOF-Modus in der Konfigurationsdatei aktivieren

3. Methode des virtuellen Speichers

Wenn Ihr Schlüssel klein und der Wert groß ist, wirkt sich die Verwendung von VM positiv aus Seien Sie besser. Da der auf diese Weise eingesparte Speicher relativ groß ist.

Wenn Ihr Schlüssel nicht klein ist, können Sie beispielsweise einige außergewöhnliche Methoden in Betracht ziehen Erwägen Sie die Kombination von Schlüssel und Wert zu einem neuen Wert.

vm-max-threads Mit diesem Parameter kann die Anzahl der Threads für den Zugriff auf die Auslagerungsdatei festgelegt werden. Es ist am besten, die Anzahl der Kerne der Maschine nicht zu überschreiten. Wenn es auf 0 gesetzt ist, erfolgt der Zugriff auf die Auslagerungsdatei alle seriell. Es kann zu einer langen Verzögerung kommen, aber die Datenintegrität ist gut gewährleistet.

Als ich es selbst getestet habe, habe ich festgestellt, dass dies der Fall ist Die Leistung bei der Verwendung des virtuellen Speichers ist ebenfalls gut. Wenn die Datenmenge groß ist, können Sie verteilte oder andere Datenbanken

15 in Betracht ziehen müssen regelmäßig bereinigt und ungültig gemacht werden. Daten erfordern eine Strategie zur Invalidierung und Eliminierung von Primärschlüsseln.

In Redis werden Schlüssel mit einer Lebensdauer als flüchtig bezeichnet. Legen Sie beim Erstellen eines Caches die Lebensdauer für einen bestimmten Schlüssel fest. Wenn der Schlüssel abläuft (die Lebensdauer ist 0), kann er gelöscht werden.

1. Einige Vorgänge, die sich auf die Überlebenszeit auswirken

Die Überlebenszeit kann entfernt werden, indem der DEL-Befehl verwendet wird, um den gesamten Schlüssel zu löschen, oder die Originaldaten können durch SET und GETSET überschrieben werden Befehle, d. h. Nach dem Ändern des dem Schlüssel entsprechenden Werts und dem Überschreiben mit demselben Schlüssel und Wert ist die Überlebenszeit der aktuellen Daten unterschiedlich.

Wenn Sie beispielsweise den INCR-Befehl für einen Schlüssel ausführen, den LPUSH-Befehl für eine Liste ausführen oder den HSET-Befehl für eine Hash-Tabelle ausführen, ändern diese Vorgänge nicht die Überlebenszeit des Schlüssels selbst. Wenn Sie andererseits RENAME zum Umbenennen eines Schlüssels verwenden, ist die Überlebenszeit des umbenannten Schlüssels dieselbe wie vor der Umbenennung.

Eine weitere Möglichkeit des RENAME-Befehls besteht darin, zu versuchen, einen Schlüssel mit einer Überlebenszeit in einen anderen_Schlüssel mit einer Überlebenszeit umzubenennen. Zu diesem Zeitpunkt wird der alte another_key (und seine Überlebenszeit) gelöscht und dann der Der alte Schlüssel wird in another_key umbenannt, sodass die Überlebenszeit des neuen another_key mit der des ursprünglichen Schlüssels übereinstimmt. Verwenden Sie den Befehl PERSIST, um die Lebensdauer des Schlüssels zu entfernen, ohne den Schlüssel zu löschen, wodurch der Schlüssel wieder zu einem dauerhaften Schlüssel wird.

2. So aktualisieren Sie die Überlebenszeit

Sie können den EXPIRE-Befehl auf einem Schlüssel ausführen, der bereits eine Überlebenszeit hat, und die neu angegebene Überlebenszeit ersetzt die alte Überlebenszeit. Die Genauigkeit der Ablaufzeit wurde innerhalb von 1 ms kontrolliert und die Zeitkomplexität des Primärschlüsselfehlers beträgt O(1). Der Befehl

EXPIRE wird zusammen mit dem TTL-Befehl verwendet, um die aktuelle Überlebenszeit anzuzeigen des Schlüssels. Gibt 1 zurück, wenn die Einstellung erfolgreich ist; gibt 0 zurück, wenn der Schlüssel nicht existiert oder die Überlebenszeit für den Schlüssel nicht festgelegt werden kann.

Maximale Cache-Konfiguration

In Redis dürfen Benutzer die maximale Speichergröße festlegen

server.maxmemory

Nach dem Login kopieren

默认为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”，我们只需要像下面一样执行即可：

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