java.util.concurrent.atomic package

Classes from java.util.concurrent.atomic package allow us to use single variables concurrently without blocking access to them. The typical usage example is increasing the counter that is modified by many threads.

Instead of using the synchronized block, that blocks the access to the counter:

	private long counter = 0;
	private final Object mutex = new Object();
	public void incrementCounter() {
	synchronized (mutex) {
	counter++;
	}
	}

view raw CounterWithSynchronizedBlock.java hosted with ❤ by GitHub

or the synchronized method equivalent to the block with 'synchronized(this)':

	public synchronized void incrementCounter() {
	counter++;
	}

view raw CounterWithSynchronizedMethod.java hosted with ❤ by GitHub

you can use AtomicLong class, that guarantees non-blocking access:

	private AtomicLong counter = new AtomicLong();
	public void incrementCounter() {
	counter.incrementAndGet();
	}

view raw CounterWithAtomicVariable.java hosted with ❤ by GitHub

Method incrementAndGet() besides incrementing counter's value, returns it.

Another typical usage is providing non-blocking access to an object, that is shared by many threads. Instead of synchronizing getter/setters methods:

	private Object resource = new Object();
	public synchronized Object getResource() {
	return resource;
	}
	public synchronized void setResource(Object resource) {
	this.resource = resource;
	}

view raw SynchronizedGettersSetters.java hosted with ❤ by GitHub

you can use AtomicReference class: