Increment Locking Comparison

package com.j256;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Quick comparison between synchronized, synchronized lock array, AtomicInteger array,
 * and Semaphore array increment loops.
 *
 * My overall point in this is that 10 MILLION iterations show a difference. The unit cost
 * of the synchronized block is negligible.
 *
 * @author graywatson
 */
public class IncrementLockingComparison {

    final int NUM_INTEGERS = 100000;
    final int NUM_THREADS = 10;

    final int[] ints = new int[NUM_INTEGERS];
    final AtomicInteger[] atomicIntegers = new AtomicInteger[ints.length];
    final Semaphore[] semaphores = new Semaphore[ints.length];
    final Object[] locks = new Object[ints.length];

    {
        for (int i = 0; i < atomicIntegers.length; i++) {
            atomicIntegers[i] = new AtomicInteger(0);
        }
        for (int i = 0; i < semaphores.length; i++) {
            semaphores[i] = new Semaphore(1);
        }
        for (int i = 0; i < locks.length; i++) {
            locks[i] = new Object();
        }
    }

    public static void main(String[] args) throws Exception {
        IncrementLockingComparison foo = new IncrementLockingComparison();
        foo.doSingleLockIncrement();
        foo.doMultipleLockIncrement();
        foo.doAtomicIncrement();
        foo.doSemaphoreIncrement();
    }

    private void doSingleLockIncrement() throws Exception {
        long before = System.currentTimeMillis();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < NUM_THREADS; i++) {
            pool.submit(new SingleLockIncrement());
        }
        pool.shutdown();
        pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
        long after = System.currentTimeMillis();
        System.out.println("Single lock = " + (after - before));
    }

    private void doMultipleLockIncrement() throws Exception {
        long before = System.currentTimeMillis();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < NUM_THREADS; i++) {
            pool.submit(new MultipleLockIncrement());
        }
        pool.shutdown();
        pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
        long after = System.currentTimeMillis();
        System.out.println("Lock array = " + (after - before));
    }

    private void doAtomicIncrement() throws Exception {
        long before = System.currentTimeMillis();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < NUM_THREADS; i++) {
            pool.submit(new AtomicIncrement());
        }
        pool.shutdown();
        pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
        long after = System.currentTimeMillis();
        System.out.println("AtomicInteger array = " + (after - before));
    }

    private void doSemaphoreIncrement() throws Exception {
        long before = System.currentTimeMillis();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < NUM_THREADS; i++) {
            pool.submit(new SemaphoreIncrement());
        }
        pool.shutdown();
        pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
        long after = System.currentTimeMillis();
        System.out.println("Semaphore array = " + (after - before));
    }

    private void doLocksIncrement() throws Exception {
        long before = System.currentTimeMillis();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < NUM_THREADS; i++) {
            pool.submit(new MultipleLockIncrement());
        }
        pool.shutdown();
        pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
        long after = System.currentTimeMillis();
        System.out.println(after - before);
    }

    private class SingleLockIncrement implements Runnable {
        @Override
        public void run() {
            Random random = new Random();
            for (int i = 0; i < 10000000; i++) {
                synchronized (ints) {
                    ints[random.nextInt(ints.length)]++;
                }
            }
        }
    }

    private class MultipleLockIncrement implements Runnable {
        @Override
        public void run() {
            Random random = new Random();
            assert ints.length == locks.length;
            for (int i = 0; i < 10000000; i++) {
                int which = random.nextInt(ints.length);
                synchronized (locks[which]) {
                    ints[which]++;
                }
            }
        }
    }

    private class AtomicIncrement implements Runnable {
        @Override
        public void run() {
            Random random = new Random();
            for (int i = 0; i < 10000000; i++) {
                atomicIntegers[random.nextInt(atomicIntegers.length)].incrementAndGet();
            }
        }
    }

    private class SemaphoreIncrement implements Runnable {
        @Override
        public void run() {
            Random random = new Random();
            assert ints.length == semaphores.length;
            for (int i = 0; i < 10000000; i++) {
                int which = random.nextInt(ints.length);
                try {
                    semaphores[which].acquire();
                } catch (InterruptedException e) {
                    return;
                }
                try {
                    ints[which]++;
                } finally {
                    semaphores[which].release();
                }
            }
        }
    }
}