浅谈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
Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Lecture et écriture de fichiers via des canaux : créez un canal pour lire les données du fichier et les transmettre via le canal. Recevez les données du canal et traitez-les. Écrivez les données traitées dans le fichier. Utilisez des goroutines pour effectuer ces opérations simultanément afin d'améliorer les performances.

La commande pipe sous Linux est un outil puissant qui peut utiliser la sortie d'une commande comme entrée d'une autre commande pour réaliser la transmission et le traitement de données entre différentes commandes. Cet article présentera les bases des commandes pipe sous Linux, ainsi que quelques exemples d'utilisation et de code courants. Introduction aux commandes de pipeline Dans les systèmes Linux, les commandes de pipeline utilisent le symbole de barre verticale (|) pour connecter deux commandes ou plus, par exemple : command1|command2 De cette façon, la sortie de command1 sera comme command2.

Dans la société de l'information d'aujourd'hui, les ordinateurs sont devenus un outil indispensable dans notre travail et dans notre vie. En tant que membre du personnel maîtrisant l'utilisation des systèmes Linux, il est très important d'utiliser les puissantes fonctions de Linux pour améliorer l'efficacité du travail. Cet article se concentrera sur la façon d'utiliser la fonction importante des tuyaux (Pipes) sous Linux pour simplifier le processus de travail et améliorer l'efficacité du travail. Un canal Linux est un type de fichier spécial qui peut transmettre la sortie d'une commande directement à une autre commande sans stocker les résultats intermédiaires.

Utilisez un canal pour implémenter un mécanisme de délai d'attente : Créez un canal. Créez une goroutine pour attendre les éléments dans le pipeline. Dans une autre goroutine, fermez le tuyau après un temps spécifié. Utilisez une instruction select pour sélectionner l'action appropriée à effectuer lorsqu'un élément de pipeline arrive ou expire.

Dans le langage Go, les fonctions et les canaux sont utilisés ensemble pour réaliser une communication inter-processus. Les fonctions peuvent transmettre des tubes en tant que paramètres pour envoyer ou recevoir des données via des tubes. Les tuyaux sont des canaux sans tampon qui peuvent être utilisés pour envoyer et recevoir des données entre des goroutines et prendre en charge les tuyaux non dirigés et dirigés. Utilisé lors de l'envoi de données

Le mécanisme de synchronisation du pipeline et de la communication des fonctions en langage Go est mis en œuvre via le blocage du tampon du pipeline pour garantir l'ordre et la sécurité de la transmission des données. Concrètement : lorsque le canal est vide, la réception des données sera bloquée. Lorsque le tuyau est plein, l’envoi de données sera bloqué. Cas pratique : Calculez la séquence de Fibonacci et utilisez des pipelines pour synchroniser la transmission des résultats de calcul.

Pipes in Go est un mécanisme de communication utilisé pour transférer des données en toute sécurité et efficacement entre les goroutines afin d'améliorer les performances des applications. Il existe deux types d'opérations de pipeline : Unbuffered : les données doivent être envoyées et reçues de manière synchrone. Buffered : le canal dispose d'un espace de stockage alloué, permettant l'envoi et la réception asynchrones. Exemple : lors du calcul de la séquence de Fibonacci, des pipelines sont utilisés pour communiquer entre la goroutine principale et la goroutine de calcul, réalisant ainsi des calculs simultanés et améliorant considérablement les performances.

Le modèle producteur-consommateur permet aux producteurs de mettre des données en cache, tandis que les consommateurs peuvent simultanément en extraire des données pour les traiter. Dans Go, les tubes sont un mécanisme de communication qui implémente ce modèle : Créez un tube : make(chanT), où T est le type de données de transfert. Fonction producteur : mettre les données dans un tube (ch
