浅谈Redis与MySQL的耦合性以及利用管道完成MySQL到Redis的高效迁_MySQL
bitsCN.com
浅谈Redis与MySQL的耦合性以及利用管道完成MySQL到Redis的高效迁移
㈠ Redis 与 MySQL 的耦合性
在业务架构早期、我们便该"吃着碗里的看着锅里的"、切莫让MySQL 有梦、而Redis 无心
毕竟、有些关系型的结构不适合放到Redis跑、"男女搭配、干活不累"嘛、推荐让MySQL与Redis喜结连理
其次、这 2 人、一般是在不同场景做选择、而不会在性能上选择、
只有在 2 者都可用的情况下、综合性能、硬件成本、运维成本等选择
比如、网页游戏启用 Redis+MySQL:
游戏中的:好友关系、排行榜、计数器、队列、cache都很适合通过 Redis来实现
再举个例子是新浪微博的架构、比如用户关注关系:
在 MySQL中是 这样一行一行存储的。而在 Redis中你可以存成一个set,或者zset等
大体流程是由 MySQL 复制到 Redis 的
基本结构应该是:
1. 发微博-- > 进入消息队列-- > 存入MySQL-- > 复制到Redis
2. 查询 -- > 查询缓存-- > 查询Redis -- > 查询MySQL
㈡ 快速迁移 MySQL →→ Redis
① MySQL 要导出的表 david_lin
[plain]
mysql> desc david_lin;
+---------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| id | int(11) | NO | PRI | NULL | |
| myname | varchar(25) | NO | UNI | NULL | |
| mymoney | int(11) | NO | | 0 | |
+---------+-------------+------+-----+---------+-------+
mysql> select * from david_lin;
+----+--------+---------+
| id | myname | mymoney |
+----+--------+---------+
| 1 | david | 100000 |
| 2 | rocky | 200000 |
+----+--------+---------+
② 编写导出脚本
每行数据中执行的 Redis命令如下:
HSET david_lin [myname] [mymoney]
[plain]
[root@odd ~]# cat mysql_to_redis.sql
SELECT CONCAT(
"*4/r/n",
'$', LENGTH(redis_cmd), '/r/n',
redis_cmd, '/r/n',
'$', LENGTH(redis_key), '/r/n',
redis_key, '/r/n',
'$', LENGTH(hkey), '/r/n',
hkey, '/r/n',
'$', LENGTH(hval), '/r/n',
hval, '/r'
)
FROM (
SELECT
'HSET' AS redis_cmd,
'david' AS redis_key,
myname AS hkey,
mymoney AS hval
FROM david_lin
) AS t
③ 开始导入
[plain]
[root@odd ~]# mysql -uroot -poracle test --skip-column-names --raw
All data transferred. Waiting for the last reply...
Last reply received from server.
errors: 0, replies: 0
④ 在Redis 里查询
[plain]
redis 127.0.0.1:6379> hgetall david
1) "david"
2) "100000"
3) "rocky"
4) "200000"
这里仅是个 demo、数据量小、不过、看这结果、有些类似行转列哈、列运算了、有木有 :)
By David Lin
2013-05-30
Good Lucky
bitsCN.com
Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

Lesen und Schreiben von Dateien über Pipes: Erstellen Sie eine Pipe, um Daten aus der Datei zu lesen und durch die Pipe zu leiten. Empfangen Sie Daten aus der Pipe und verarbeiten Sie sie. Schreiben Sie die verarbeiteten Daten in die Datei. Verwenden Sie Goroutinen, um diese Vorgänge gleichzeitig auszuführen, um die Leistung zu verbessern

Der Pipe-Befehl unter Linux ist ein leistungsstarkes Tool, das die Ausgabe eines Befehls als Eingabe eines anderen Befehls verwenden kann, um die Datenübertragung und -verarbeitung zwischen verschiedenen Befehlen zu realisieren. In diesem Artikel werden die Grundlagen von Pipe-Befehlen unter Linux sowie einige allgemeine Verwendungs- und Codebeispiele vorgestellt. Einführung in Pipeline-Befehle In Linux-Systemen verwenden Pipeline-Befehle das vertikale Balkensymbol (|), um zwei oder mehr Befehle zu verbinden, zum Beispiel: Befehl1|Befehl2. Auf diese Weise wird die Ausgabe von Befehl1 als Befehl2 angezeigt

In der heutigen Informationsgesellschaft sind Computer zu einem unverzichtbaren Werkzeug in unserer Arbeit und unserem Leben geworden. Als Mitarbeiter, der sich mit Linux-Systemen auskennt, ist es sehr wichtig, die leistungsstarken Funktionen von Linux zu nutzen, um die Arbeitseffizienz zu verbessern. Dieser Artikel konzentriert sich darauf, wie man die wichtige Funktion von Pipes (Pipes) in Linux nutzt, um den Arbeitsprozess zu vereinfachen und die Arbeitseffizienz zu verbessern. Eine Linux-Pipe ist ein spezieller Dateityp, der die Ausgabe eines Befehls direkt an einen anderen Befehl übergeben kann, ohne die Zwischenergebnisse zu speichern.

Verwenden Sie eine Pipe, um einen Timeout-Mechanismus zu implementieren: Erstellen Sie eine Pipe. Erstellen Sie eine Goroutine, um auf Elemente in der Pipeline zu warten. Schließen Sie in einer anderen Goroutine die Pipe nach einer bestimmten Zeit. Verwenden Sie eine Select-Anweisung, um die entsprechende Aktion auszuwählen, die ausgeführt werden soll, wenn ein Pipeline-Element eintrifft oder das Zeitlimit überschreitet.

In der Go-Sprache werden Funktionen und Pipes gemeinsam verwendet, um eine Kommunikation zwischen Prozessen zu erreichen. Funktionen können Pipes als Parameter übergeben, um Daten über Pipes zu senden oder zu empfangen. Pipes sind ungepufferte Kanäle, die zum Senden und Empfangen von Daten zwischen Goroutinen verwendet werden können und sowohl ungerichtete als auch gerichtete Pipes unterstützen. Wird beim Senden von Daten verwendet

Der Synchronisationsmechanismus der Pipeline- und Funktionskommunikation in der Go-Sprache wird durch Pipeline-Pufferblockierung implementiert, um die Reihenfolge und Sicherheit der Datenübertragung sicherzustellen. Konkret: Wenn die Pipe leer ist, wird der Datenempfang blockiert. Wenn die Pipe voll ist, wird das Senden von Daten blockiert. Praxisfall: Berechnen Sie die Fibonacci-Folge und verwenden Sie Pipelines, um die Übertragung der Berechnungsergebnisse zu synchronisieren.

Pipes in Go sind ein Kommunikationsmechanismus, der zur sicheren und effizienten Übertragung von Daten zwischen Goroutinen verwendet wird, um die Anwendungsleistung zu verbessern. Es gibt zwei Arten von Pipeline-Operationen: Ungepuffert: Daten müssen synchron gesendet und empfangen werden. Gepuffert: Der Pipe ist Speicherplatz zugewiesen, der asynchrones Senden und Empfangen ermöglicht. Beispiel: Bei der Berechnung der Fibonacci-Folge werden Pipelines verwendet, um zwischen der Haupt-Goroutine und der Berechnungs-Goroutine zu kommunizieren, wodurch gleichzeitige Berechnungen erreicht und die Leistung erheblich verbessert werden.

Unter Linux ist eine Pipe ein Kommunikationsmechanismus, der die Ausgabe eines Programms direkt mit der Eingabe eines anderen Programms verbindet. Im Wesentlichen ist eine Pipe auch eine Art Datei, unterscheidet sich jedoch von einer allgemeinen Datei. Pipes können zwei Probleme bei der Verwendung von Dateien für die Kommunikation überwinden. Die spezifischen Erscheinungsformen sind: Die Größe der Pipe wird begrenzt und der Lesevorgang kann funktionieren schneller als Der Schreibvorgang ist schnell.
