synchronisation sur deux ou plusieurs objets (Java)

Question

I ont un code similaire à ce qui suit:

public class Cache{ 
private final Object lock = new Object(); 
private HashMap<Integer, TreeMap<Long, Integer>> cache = 
    new HashMap<Integer, TreeMap<Long, Integer>>(); 
private AtomicLong FREESPACE = new AtomicLong(102400); 

private void putInCache(TreeMap<Long, Integer> tempMap, int fileNr){ 
    int length; //holds the length of data in tempMap 
    synchronized(lock){ 
    if(checkFreeSpace(length)){ 
    cache.get(fileNr).putAll(tmpMap); 
    FREESPACE.getAndAdd(-length); 
    } 
    } 
} 

private boolean checkFreeSpace(int length){  
    while(FREESPACE.get() < length && thereIsSomethingToDelete()){ 
    // deleteSomething returns the length of deleted data or 0 if 
    // it could not delete anything 
    FREESPACE.getAndAdd(deleteSomething(length)); 
    } 
    if(FREESPACE.get() < length) return true; 
    return false; 
} 
} 

putInCache est appelé par environ 139 fils par seconde. Puis-je être sûr que ces deux méthodes vont se synchroniser sur les deux cache et FREESPACE? En outre, checkFreeSpace() multithread-safe est-ce que je peux être sûr qu'il y aura seulement une invocation de cette méthode à la fois? Le "multithread-safety" de ce code peut-il être amélioré?

Answer 1

Vous ne synchronisez généralement pas sur les champs dont vous voulez contrôler l'accès directement. Les champs auxquels vous voulez synchroniser l'accès doivent uniquement être accessibles à partir de blocs synchronisés (sur le même objet) pour être considérés comme sécurisés. Vous le faites déjà en putInCache(). Par conséquent, étant donné que checkFreeSpace() accède à l'état partagé de manière non synchronisée, il n'est pas thread-safe.

Answer 2

Pour obtenir une réponse complète à votre question, vous devez afficher les implémentations des méthodes thereIsSomethingToDelete() et deleteSomething(). Etant donné que checkFreeSpace est une méthode publique (est-ce vraiment nécessaire?) Et n'est pas synchronisé, il est possible qu'il puisse être appelé par un autre thread pendant que le bloc synchronisé dans la méthode putInCache() est en cours d'exécution. Cela en soi pourrait ne rien casser, car il semble que la méthode checkFreeSpace peut seulement augmenter la quantité d'espace libre, pas la réduire. Ce qui serait plus grave (et l'exemple de code ne nous permet pas de le déterminer) est que les méthodes thereIsSomethingToDelete() et deleteSomething() ne synchronisent pas correctement leur accès à l'objet cache, en utilisant le même objet. lock utilisé par putInCache().