Carte concurrente à taille fixe

J’ai besoin d’une carte avec les conditions suivantes:

Cela devrait être hautement concurrentiel. Les méthodes put() , get() et remove() peuvent être appelées simultanément par plusieurs threads.
Il devrait être de taille fixe. Si la taille de HashMap atteint la valeur maximale (par exemple, 10000), l’ajout d’une nouvelle entrée à la carte ne devrait pas être autorisé. Il NE PEUT PAS être un cache LRU où l’entrée la plus ancienne est supprimée lorsque la taille maximale est atteinte.

ConcurrentHashMap peut satisfaire # 1. Mais je ne sais pas comment N ° 2 peut être implémenté au dessus de ConcurrentHashMap sans impacter la simultanéité (l’ajout d’une méthode put() personnalisée qui n’appenda à la carte que lorsque sa taille est inférieure à la taille maximale doit HashMap le but d’utiliser HashMap simultané).

S’il vous plaît laissez-moi savoir vos pensées.

Vous pouvez implémenter une carte qui délègue à un ConcurrentHashMap, en utilisant un sémaphore de comptage pour limiter le nombre d’éléments de la carte. La classe Semaphore utilise un int mis à jour de manière atomique pour garder une trace des permis, afin d’éviter des frais généraux supplémentaires.

Vous pouvez faire tout cela vous-même, et l’arsenal java SE peut à lui seul répondre à vos besoins, mais je recommande fortement une méthodologie plus simple et plus évolutive, car tout ce travail vous-même reviendrait à réinventer la roue. Essayez l’une de ces grids de données en mémoire:

Ehcache
Hazelcast

Par exemple, dans ehcache, vous pouvez réaliser ce que vous voulez avec une configuration similaire à:

Si vous utilisez ConcurrentHashMap, qui est le choix évident ici, utilisez ensuite l’entrée concurrencyLevel du constructeur pour augmenter la bande passante. Cette méthode segmente la carte en plusieurs zones pour éviter les conflits d’emplacement.

Pourquoi ne pas conserver la taille de Hashmap à tout moment pour garantir le nombre total d’éléments insérés? Vous pouvez utiliser AtomicInteger pour ne pas avoir à synchroniser / verrouiller un int normal et à sacrifier l’avantage de l’utilisation de ConcurrentHashMap.