Lecture recommandée
Pratique du projet : meilleures pratiques pour la reconnaissance OCR de texte par IA
AI Gamma génère un lien direct vers l'outil PPT en un seul clic
Jouez avec cloud Studio, l'outil de codage en ligne
Jouez avec la peinture IA GPU, la parole IA, la traduction, le GPU illumine l'espace d'imagination IA
Partage d'information
Le document le plus complet de l'histoire de l'IA peignant le partage de données de diffusion stable
Peinture IA sur l'encyclopédie SD, MJ, GPT, SDXL
Peinture AI, diffusion stable, document GPT officiel de Midjourney, collecte de données de l'encyclopédie AIGC
「java、python面试题」来自UC网盘app分享，打开手机app，额外获得1T空间
https://drive.uc.cn/s/2aeb6c2dcedd4
AIGC资料包
https://drive.uc.cn/s/6077fc42116d4
https://pan.xunlei.com/s/VN_qC7kwpKFgKLto4KgP4Do_A1?pwd=7kbv#
La gestion des verrous dans les systèmes distribués a toujours été un problème complexe et critique
. Dans ce domaine, le framework Redisson est devenu l'un des premiers choix des développeurs en raison de ses excellentes performances et fonctionnalités. Ce blog discutera en profondeur du principe de fonctionnement du verrou distribué du framework Redisson et des points de connaissances avancés impliqués. Grâce à des explications détaillées et des exemples de code, vous comprendrez mieux comment utiliser le framework Redisson pour implémenter des verrous distribués dans un environnement distribué.
introduction
Dans un système distribué, plusieurs nœuds doivent travailler ensemble pour accomplir des tâches, mais dans certains cas, afin de garantir la cohérence et l'exactitude des données, des verrous distribués doivent être introduits. Redisson est un framework Java basé sur Redis qui permet la mise en œuvre de verrous distribués. Il est non seulement facile à utiliser, mais offre également d'excellentes performances. Avant d'aborder le principe des verrous distribués Redisson, comprenons d'abord les concepts de base des verrous distribués.
Le concept de base du verrouillage distribué
Les verrous distribués sont un mécanisme utilisé pour contrôler l'accès aux ressources partagées par plusieurs nœuds dans un système distribué. Il garantit qu'à un moment donné, un seul nœud peut détenir le verrou et que seul le nœud détenant le verrou peut exécuter des blocs de code critiques. Les verrous distribués doivent généralement remplir les conditions suivantes :
- Exclusivité mutuelle : un seul nœud peut détenir le verrou en même temps.
- Réentrée : permet au nœud détenant le verrou d'acquérir à nouveau le verrou après l'avoir libéré.
- Sécurité : garantit que même en cas de panne d'un nœud ou de panne du réseau, le verrou n'est pas occupé en permanence.
- Haute performance : l'acquisition et la libération du verrou doivent être des opérations efficaces.
Tout en remplissant ces conditions, le framework Redisson fournit également des fonctions avancées pour rendre les verrous distribués plus puissants et plus flexibles.
Présentation du cadre Redisson
Redisson est un framework Java basé sur Redis.Il permet la mise en œuvre d'une variété d'objets et de services distribués, notamment des verrous distribués, des collections distribuées, des files d'attente de messages distribuées, etc. Cet article se concentre sur l'implémentation du verrouillage distribué du framework Redisson.
La serrure distribuée de Redisson fournit non seulement les fonctions des serrures conventionnelles, mais comprend également les fonctionnalités suivantes :
- Verrou réentrant : Le même thread peut acquérir le même verrou plusieurs fois.
- Fair lock : implémenté sur la base de l'ensemble ordonné de Redis, garantissant que le thread qui attend le plus longtemps acquiert le verrou en premier.
- Interverrouillage : prend en charge l'acquisition de plusieurs verrous en même temps pour éviter les blocages.
- Verrou rouge : obtenez des verrous sur plusieurs nœuds Redis pour garantir une haute disponibilité.
- Verrouillage en lecture-écriture : prend en charge le verrouillage en lecture et le verrouillage en écriture, permettant d'effectuer plusieurs opérations de lecture simultanément.
Le principe de fonctionnement de la serrure distribuée Redisson
Le verrouillage distribué du framework Redisson est implémenté sur la base de la structure de données de Redis, qui utilise principalement les deux structures de données suivantes :
- Chaîne Redis (String) : utilisée pour stocker le détenteur du verrou et la période de validité du verrou.
- Collection ordonnée de Redis (Sorted Set) : utilisée pour réaliser les opérations d'équité des verrous et de déverrouillage.
Ci-dessous, nous approfondirons le principe de fonctionnement du verrou distribué Redisson :
Acquisition de serrure
- Lorsqu'un thread tente d'acquérir un verrou, Redisson crée une paire clé-valeur de chaîne dans Redis. La clé est le nom du verrou et la valeur est l'identifiant unique du thread (généralement l'ID du thread).
- Si le verrou est acquis avec succès, Redisson définira un délai d'expiration pour éviter que le verrou ne soit occupé pendant une longue période. Les délais d'expiration utilisent généralement des valeurs aléatoires pour éviter les conflits de délais d'expiration des verrous.
- Si l'acquisition du verrou échoue, Redisson attendra un certain temps, puis réessayera. Ce temps d'attente est généralement randomisé pour réduire les conflits de verrouillage.
déverrouillage
- Lorsqu'un thread libère un verrou, Redisson vérifie si le support du verrou correspond au thread actuel. S'il y a une correspondance, Redisson supprimera la paire clé-valeur du verrou et libérera le verrou.
- Si le thread détenant le verrou ne l'a pas libéré après l'expiration du verrou, d'autres threads peuvent tenter d'acquérir le verrou.
verrouiller l'équité
Les serrures équitables de Redisson sont mises en œuvre à travers des collections commandées. Chaque verrou correspond à un ensemble ordonné, et les membres de l'ensemble sont des threads en attente du verrou, et le score est l'horodatage d'attente du thread. Lors de l'acquisition d'un verrou, Redisson ajoutera des threads à un ensemble ordonné, trié par horodatage. Lorsque le verrou est libéré, Redisson supprimera le thread de l'ensemble trié, de sorte que le thread avec le temps d'attente le plus long acquière le verrou, réalisant ainsi l'équité.
Points de connaissances avancés
En plus des principes de base du verrouillage distribué, le framework Redisson implique également quelques points de connaissances avancés qui peuvent vous aider à mieux comprendre et utiliser les verrous distribués Redisson :
1. Verrouillage
Le verrouillage de Redisson permet d'acquérir plusieurs verrous en même temps pour éviter les situations de blocage. Lorsque plusieurs threads doivent acquérir plusieurs verrous, un blocage peut être efficacement évité si les verrous sont acquis dans le même ordre.
Exemple de code :
RBatch batch = redisson.createBatch();
RLock lock1 = batch.getLock("lock1");
RLock lock2 = batch.getLock("lock2");
batch.execute();
boolean hasLocks = redisson.getLock(lock1, lock2);
if (hasLocks) {
try {
// 执行需要锁保护的代码
} finally {
redisson.unlock(lock1, lock2);
}
}
Dans l'exemple ci-dessus, nous avons RLockcréé deux objets de verrouillage et redisson.getLock()acquis ces deux verrous. Ensuite, avant d'exécuter le bloc de code qui nécessite une protection par verrou, nous redisson.unlock()libérons les deux verrous. De cette façon, vous garantissez qu’aucun blocage ne se produit lors de l’acquisition de plusieurs verrous.
2. Serrure rouge
Le verrou rouge de Redisson est un verrou distribué à haute disponibilité qui peut acquérir des verrous sur plusieurs nœuds Redis pour garantir que même en cas de défaillance de certains nœuds, les verrous peuvent être acquis normalement. La mise en œuvre du verrou rouge est basée sur l'algorithme Quorum, qui garantit que le verrou ne peut être acquis que lorsque la plupart des nœuds sont disponibles.
Exemple de code :
RRedLock redLock = new RRedLock("lock1", "lock2", "lock3");
boolean hasLocks = redLock.tryLock(10, TimeUnit.SECONDS);
if (hasLocks) {
try {
// 执行需要锁保护的代码
} finally {
redLock.unlock();
}
}
Dans l'exemple ci-dessus, nous RRedLockcréons un objet verrou rouge en utilisant , puis redLock.tryLock()essayons d'acquérir le verrou en utilisant . Si une majorité de nœuds réussissent à acquérir le verrou, le code protégé par le verrou est exécuté.
3. Verrouillage en lecture-écriture
Redisson prend en charge les verrous en lecture-écriture, permettant à plusieurs threads de lire les ressources partagées en même temps, mais n'autorise qu'un seul thread à écrire des ressources. Cela peut améliorer les performances dans certains scénarios.
Exemple de code :
RReadWriteLock rwLock = redisson.getReadWriteLock("myReadWriteLock");
RLock readLock = rwLock.readLock();
RLock writeLock = rwLock.writeLock();
// 获取读锁
readLock.lock();
try {
// 执行读操作
} finally {
readLock.unlock();
}
// 获取写锁
writeLock.lock();
try {
// 执行写操作
} finally {
writeLock.unlock();
}
Dans l'exemple ci-dessus, nous utilisons RReadWriteLockpour créer un objet de verrouillage en lecture-écriture et utilisons readLocket writeLockpour acquérir respectivement des verrous en lecture et en écriture. De cette façon, plusieurs threads peuvent lire les ressources en même temps, mais un seul thread peut écrire des ressources.
Exemple de démonstration de code
Vous trouverez ci-dessous un exemple simple qui montre comment utiliser le framework Redisson pour implémenter des verrous distribués et comment utiliser les fonctionnalités avancées :
public class DistributedLockDemo {
public static void main(String[] args) {
Config config = new Config();
config.useSingleServer().setAddress("redis://localhost:6379");
RedissonClient redisson = Redisson.create(config);
RLock lock = redisson.getLock("myLock");
try {
boolean isLocked = lock.tryLock(10, 60, TimeUnit.SECONDS);
if (isLocked) {
System.out.println("Lock acquired. Performing some critical task...");
Thread.sleep(5000); // Simulate some critical task
System.out.println("Critical task completed.");
} else {
System.out.println("Failed to acquire lock. Another process holds it.");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
redisson.shutdown();
}
}
Dans cet exemple, nous créons un client Redisson, acquérons un verrou nommé « myLock », puis tentons d'acquérir le verrou et d'effectuer des tâches clés. Si le verrou est détenu par un autre thread, il attendra un moment et réessayera. Enfin, nous libérons le verrou et fermons le client Redisson.
en conclusion
Grâce à l'explication détaillée et à l'exemple de code de cet article, vous devriez maintenant avoir une compréhension plus approfondie des principes de verrouillage distribué et des points de connaissances avancés du framework Redisson. Le framework Redisson fournit non seulement des fonctions de verrouillage distribué de base, mais prend également en charge des fonctions avancées telles que les verrous réentrants, les verrous équitables, les verrouillages, les verrous rouges et les verrous en lecture-écriture, rendant la gestion des verrous distribués plus flexible et fiable.
Si vous devez utiliser des verrous distribués pour gérer l'accès aux ressources partagées dans un système distribué, le framework Redisson est une solution puissante et mature. J'espère que cet article vous a été utile. Si vous avez des questions ou des commentaires, partagez-les dans les commentaires ci-dessous et explorons ensemble les mystères des verrous distribués ! En même temps, si vous pensez que cet article vous est utile, n'hésitez pas à l'aimer, à le commenter et à le partager avec davantage de développeurs. Merci pour la lecture!