Maggiore di scambio confrontare-e-

Question

Come suggerisce il titolo, sto cercando un'implementazione confronto-e-swap, ma con maggiore di confronto:

if(newValue > oldValue) { 
    oldValue = newValue; 
} 

dove oldValue è un certo stato condiviso globale e newValue è privato per ogni thread, senza fare questo:

synchronized(locker) { 
    if(newValue > oldValue) { 
     oldValue = newValue; 
    }  
} 

perché voglio una soluzione non-blocking. Dallo studio codici sorgente di altre operazioni non bloccanti, sono venuto con questa (supponendo che i valori sono numeri interi):

AtomicInteger oldValue; // shared global variable 

... 

public boolean GreaterThanCAS(int newValue) { 

    while(true) { 
     int local = oldValue; 
     if(local == oldValue) { 
      if(newValue > local) { 
       if(oldValue.compareAndSet(local, newValue) { 
        return true; // swap successful 
       } // else keep looping 
      } else { 
       return false; // swap failed 
      } 
     } // else keep looping 
    } 
} 

quando // else keep looping accade, significa che un altro thread ha cambiato il oldValue nel frattempo quindi ho bisogno di fare un ciclo e riprovare.

Questa implementazione è corretta (thread-safe)?

Answer 1

Non vedo problemi con l'implementazione, , a condizione che nessun thread diminuisca mai il valore di AtomicInteger. Se lo fanno, il tuo codice è aperto alle condizioni di gara.

Si noti che il codice può essere semplificata come segue:

public boolean GreaterThanCAS(int newValue) { 
    while(true) { 
     int local = oldValue.get(); 
     if(newValue <= local) { 
      return false; // swap failed 
     } 
     if(oldValue.compareAndSet(local, newValue)) { 
      return true; // swap successful 
     } 
     // keep trying 
    } 
} 

Answer 2

avrei ri scriverlo a guardare più come:

while(true) { 
    int local = oldValue.get(); 
    if(newValue > local){ 
     if(oldValue.compareAndSwap(local, newValue) { 
       return true; // swap successful 
     } // else keep looping 
    }else 
     return false; 
} 

La verifica di equivalenza prima che il maggiore di controllo è ridondante.

Altrimenti dovrebbe funzionare correttamente.

Answer 3

Dal Java 8 questo può essere semplificato con l'utilizzo di updateAndGet:

public boolean greaterThanCAS(int newValue) { 
    return oldValue.updateAndGet(x -> x < newValue ? newValue : x) == newValue; 
} 

Si noti che questo sarebbe tornato vero anche nel caso in cui vecchi e nuovi valori sono uguali. Provare a @Adam's answer se questo non è il comportamento desiderato.

Answer 4

@Vadzim, avrei commentato il tuo post, ma StackOverflow dice che non ho abbastanza punti per postare commenti. La tua risposta è quasi corretta, ma la tua funzione restituirà sempre false perché getAndUpdate restituisce sempre il valore precedente, o 'x' nel tuo caso. Credo che tutto quello che avrebbe bisogno di fare è sostituire il vostro ultimo '==' con '<', ad esempio:

// return true if the assignment was made, false otherwise 
public boolean greaterThanCAS(int newValue) { 
    return oldValue.getAndUpdate(x -> x < newValue ? newValue : x) < newValue; 
}