Différence de Performance de AtomicInteger vs Entier

Le choix de ces deux types ne doit pas dépendre de la performance. Le choix principal pour AtomicInteger est, si vous voulez parvenir à la sécurité des threads avec les opérations sur les entiers.

Cependant, la différence de performance peut fortement dépendre de la choisi du système d'exploitation, comme la mise en œuvre des opérations atomiques dépendent du système d'exploitation.

OriginalL'auteur tune2fs

AtomicInteger permet à certains (pas tous!) les opérations qui seraient autrement nécessitent une synchronisation être effectuée dans une serrure manière sans l'aide de matériel spécifique instructions. Comment cela affecte la performance est un peu complexe:

• Tout d'abord, il s'agit d'un micro-optimisation, qui ne fera qu'importe si cette opération est sur votre application de chemin critique.
• Le matériel spécial instructions peuvent ne pas être disponibles sur la non-généralisation des plates-formes, dans lequel cas AtomicInteger seront probablement mises en œuvre à l'aide de la synchronisation.
• La JVM peut souvent optimiser loin verrouillage lorsqu'il n'existe aucun conflit (par exemple, un seul thread de l'application). Dans ce cas, il n'y a probablement pas de différence.
• Si il est faible à modéré de verrouillage (c'est à dire plusieurs threads, mais ils ont surtout faire d'autres choses que le simple accès à ce nombre entier), le lock-free algorithme plus performant que la synchronisation.
• Si il est très lourd de verrouillage (c'est à dire beaucoup de fils qui passent beaucoup de temps à essayer d'accéder à ce nombre entier), la synchronisation peut être meilleur parce que le lock-free algorithme est basé sur la permanence de retenter l'opération lorsqu'il échoue en raison d'une collision.

OriginalL'auteur Michael Borgwardt

Suis tombé sur ce poste aujourd'hui mais je voulais partager mes résultats (Svp pas de commentaires sur le code que j'ai eu à main type les classes suivantes, comme le système que j'ai couru ce un n'était pas connecté à l'internet 🙂

Bas de ligne de la sortie à partir du code ci-dessous a été comme suit:

ATOMIQUE Résultats: Elapsed = 25257 ms, ExpectedValue = 50000, FinalValue = 50000, vrai
PrImItIvE Résultats: Elapsed = 25257 ms, ExpectedValue = 50000, FinalValue = 48991, faux

Pour mon utilisation de mon application, j'ai choisi d'utiliser les valeurs Atomiques pour le statut de numéros en un de la surveillance de la classe. Dans le cas où quelqu'un d'autre voulais voir quelques résultats que j'ai choisi de publier cette information.

Ont un grand jour!

Classes:

J'ai créé une classe principale avec une primitive de long et atomique de long et accesseur incrément de méthodes, une IncrementAtomicRunnable et un IncrementPrimitiveRunnable.

LongOverhead:

public class LongOverhead{
AtomicLong atomicLong;
long primitiveLong;
public LongOverhead(){
atomicLong = new AtomicLong(0l);
primitiveLong = 0l;
}
public void incrAtomicLong(){
atomicLong.getAndAdd(1l);
}
public long getAtomicLong(){
return atomicLong.get();
}
public void incrPrimitiveLong(){
primitiveLong++;
}
public long getPrimitiveLong(){
return primitiveLong;
}
public static void main(String [] args){
String template = "%s Results:  Elapsed = %d ms, ExpectedValue = %d, FinalValue = %d, %b";
int loopTotal = 1000;
int waitMilliseconds = 25;
int totalThreads = 50;
int expectedValue = loopTotal * totalThreads;
int whileSleep = 250;
LongOverhead atomic = new LongOverhead();
LongOverhead primitive = new LongOverhead();
List<Thread> atomicThreads = new ArrayList<>();
List<Thread> primitiveThreads = new ArrayList<>();
for(int x=0;x<totalThreads;x++){
Thread a = new Thread(new IncrementalAtomicRunnable(atomic, loopTotal, waitMilliseconds), "AtomicIncr" + x);
atomicThreads.add(a);
Thread p = new Thread(new IncrementalPrimitiveRunnable(primitive, loopTotal, waitMilliseconds), "PrimitiveIncr" + x);
primitiveThreads.add(p);
}
boolean cont = true;
long atomicStart = System.currentTimeMillis();
for(Thread t:  atomicThreads){
t.start();
}
while(cont){
try{
Thread.sleep(whileSleep);
}catch(InterruptedException e){
e.printStackTrace();
}
boolean foundAlive = false;
for(Thread t: atomicThreads){
foundAlive = (State.TERMINATED != t.getState());
if(foundAlive){
break;
}
}
cont = foundAlive;
}
long atomicFinish = System.currentTimeMillis();
long atomicElapsed = atomicFinish - atomicStart;
long atomicFinal = atomic.getAtomicLong();
cont = true;
long primitiveStart = System.currentTimeMillis();
for(Thread t:  primitiveThreads){
t.start();
}
while(cont){
try{
Thread.sleep(whileSleep);
}catch(InterruptedException e){
e.printStackTrace();
}
boolean foundAlive = false;
for(Thread t: primitiveThreads){
foundAlive = (State.TERMINATED != t.getState());
if(foundAlive){
break;
}
}
cont = foundAlive;
long primitiveFinish = System.currentTimeMillis();
long primitiveElapsed = primitiveFinish - primitiveStart;
long primitiveFinal = primitive.getPrimitiveLong();
System.out.println(String.format(template, "ATOMIC", atomicElapsed, expectedValue, atomicFinal, (expectedValue==atomicFinal)));
System.out.println(String.format(template, "PrImItIvE", primitiveElapsed, expectedValue, primitiveFinal, (expectedValue==primitiveFinal)));
}

IncrementAtomicRunnable:

public class IncrementAtomicRunnable implements Runnable{
protected LongOverhead oh;
protected int loopTotal;
protected int waitMilliseconds;
protected String currentThreadName;
public IncrementAtomicRunnable(LongOverhead oh, int loopTotal, int waitMilliseconds){
this.oh = oh;
this.loopTotal = loopTotal;
this.waitMilliseconds = waitMilliseconds;
}
@Override
public void run(){
currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " for ATOMIC is starting.....");
for(int x=0;x<loopTotal;x++){
oh.incrAtomicLong();
try{
Thread.sleep(waitMilliseconds);
}catch(InterruptedException e){
System.out.println("InterruptedThread[" + currentThreadName + "], eating exception @@@@@");
}
}
System.out.println("....." + currentThreadName + " for ATOMIC is finished.");
}
}

et enfin
IncrementPrimitiveRunnable:

public class IncrementPrimitiveRunnable extends IncrementAtomicRunnable{
public IncrmentPrimitiveRunnable(LongOverhead oh, int loopTotal, int waitMilliseconds){
super(oh, loopTotal, waitMilliseconds);
}
@Override
public void run(){
super.currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " for PRIMITIVE is starting.....");
for(int x=0;x<loopTotal;x++){
oh.incrPrimitiveLong();
try{
Thread.sleep(waitMilliseconds);
}catch(InterruptedException e){
System.out.println("InterruptedThread[" + currentThreadName + "], eating exception @@@@@");
}
}
System.out.println("....." + currentThreadName + " for PRIMITIVE is finished.");
}
}

OriginalL'auteur JavaJd