java - how - ¿Cuándo se prefiere AtomicInteger en lugar de sincronizado?

atomicinteger java ejemplo

Question

Como AtomicInteger puede ser al menos un orden de magnitud más lento que un int protegido por synchronized , ¿por qué querría usar AtomicInteger?

Por ejemplo, si todo lo que quiero es incrementar un valor int de una manera segura para subprocesos, ¿por qué no usar siempre :

synchronized(threadsafeint) {
threadsafeint++;
}

en lugar de utilizar AtomicInteger.incrementAndGet (), mucho más lento

Answer 1

Como AtomicInteger puede ser al menos un orden de magnitud más lento que un int protegido por sincronización, ¿por qué querría usar AtomicInteger?

AtomicInteger es mucho más rápido.

static final Object LOCK1 = new Object();
static final Object LOCK2 = new Object();
static int i1 = 0;
static int i2 = 0;
static final AtomicInteger ai1 = new AtomicInteger();
static final AtomicInteger ai2 = new AtomicInteger();
public static void main(String... args) throws IOException {
for(int i=0;i<5;i++) {
testSyncInt();
testAtomicInt();
}
}
private static void testSyncInt() {
long start = System.nanoTime();
int runs = 10000000;
for(int i=0;i< runs;i+=2) {
synchronized (LOCK1) {
i1++;
}
synchronized (LOCK2) {
i2++;
}
}
long time = System.nanoTime() - start;
System.out.printf("sync + incr: Each increment took an average of %.1f ns%n", (double) time/runs);
}
private static void testAtomicInt() {
long start = System.nanoTime();
int runs = 10000000;
for(int i=0;i< runs;i+=2) {
ai1.incrementAndGet();
ai2.incrementAndGet();
}
long time = System.nanoTime() - start;
System.out.printf("incrementAndGet: Each increment took an average of %.1f ns%n", (double) time/runs);
}

huellas dactilares

sync + incr: Each increment took an average of 32.4 ns
incrementAndGet: Each increment took an average of 20.6 ns
sync + incr: Each increment took an average of 31.4 ns
incrementAndGet: Each increment took an average of 12.9 ns
sync + incr: Each increment took an average of 29.6 ns
incrementAndGet: Each increment took an average of 12.9 ns
sync + incr: Each increment took an average of 35.1 ns
incrementAndGet: Each increment took an average of 16.6 ns
sync + incr: Each increment took an average of 29.9 ns
incrementAndGet: Each increment took an average of 13.0 ns

Agregando alguna contención como @assylias sugiere. Muestra que cuando solo estás usando un hilo, la CPU puede optimizar el acceso.

static final Object LOCK1 = new Object();
static final Object LOCK2 = new Object();
static int i1 = 0;
static int i2 = 0;
static final AtomicInteger ai1 = new AtomicInteger();
static final AtomicInteger ai2 = new AtomicInteger();
public static void main(String... args) throws ExecutionException, InterruptedException {
for(int i=0;i<5;i++) {
testSyncInt();
testAtomicInt();
}
}
private static void testSyncInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
synchronized (LOCK1) {
i1++;
}
synchronized (LOCK2) {
i2++;
}
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("sync + incr: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}
private static void testAtomicInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
ai1.incrementAndGet();
ai2.incrementAndGet();
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("incrementAndGet: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}

huellas dactilares

sync + incr: Each increment took an average of 478.6 ns
incrementAndGet: Each increment took an average of 191.5 ns
sync + incr: Each increment took an average of 437.5 ns
incrementAndGet: Each increment took an average of 169.8 ns
sync + incr: Each increment took an average of 408.1 ns
incrementAndGet: Each increment took an average of 180.8 ns
sync + incr: Each increment took an average of 511.5 ns
incrementAndGet: Each increment took an average of 313.4 ns
sync + incr: Each increment took an average of 441.6 ns
incrementAndGet: Each increment took an average of 219.7 ns

Answer 2

si realmente desea obtener más detalles sobre por qué java.util.concurrent stuff es mejor y cuál es la diferencia en comparación con el enfoque sincronizado clásico, lea este enlace (y todo el blog en general)