ACHIEVING SYNCHRONIZATION
FOR A SHARED INSTANCE BETWEEN MULTIPLE THREADS
Lets suppose we have many threads operating simultaneously on an instance which increments a counter by 1
But we don't want 2 or more to operate at the same time
Because this will create inconsistencies on our controlled adding - counter may increase faster and lose a value.
So, only one thread should have access to read and write at each moment.
The next thread should get the last value and increment/write on it.
And so on.
THREADS AND MAIN MEMORY
WITH SYNCHRONIZED KEYWORD
Class/Instance for incrementing counter
public class SynchronizationWithSynchronizedKeyword {
private int counter;
int getValue() {
return counter;
}
synchronized void incrementBy1() {
counter++;
}
}
- Synchronized keyword will:
- Stop other threads from accessing (locking)
- Read the last value from the main memory
- Increment it by 1
- Write the new value in shared memory
Testing
@Test
public void test1() throws InterruptedException {
ExecutorService service = Executors.newFixedThreadPool(3);
SynchronizationWithSynchronizedKeyword syncWithKeyword = new SynchronizationWithSynchronizedKeyword();
IntStream.range(0, 1000).forEach(count -> service.execute(syncWithKeyword::incrementBy1));
shutdownAndAwaitTermination(service);
assertEquals(1000, syncWithKeyword.getValue());
}
- Shared instance: syncWithKeyword
- We initiate 1000 Runnable tasks via a 3-Thread pool
- These tasks reference the shared instance's increment method
- To pass test, each task should increase the counter variable by 1, adding totally to 1000.
Helper method to gracefully shutdown the executor threads
private void shutdownAndAwaitTermination(ExecutorService pool) {
// Disable new tasks from being submitted
pool.shutdown();
try {
// Wait a while for existing tasks to terminate
if (!pool.awaitTermination(100, TimeUnit.MILLISECONDS)) {
// Cancel currently executing tasks forcefully
pool.shutdownNow();
// Wait a while for tasks to respond to being cancelled
if (!pool.awaitTermination(100, TimeUnit.MILLISECONDS))
System.err.println("Pool did not terminate");
}
} catch (InterruptedException ex) {
// (Re-)Cancel if current thread also interrupted
pool.shutdownNow();
// Preserve interrupt status
Thread.currentThread().interrupt();
}
}
Result: Success
WITH ATOMIC VARIABLE CLASSES
Class/Instance for incrementing counter
public class SynchronizationWithAtomicClasses {
private final AtomicInteger counter = new AtomicInteger(0);
int getValue() {
return counter.get();
}
void incrementBy1() {
counter.incrementAndGet();
}
}
- AtomicInteger's incrementAndGet when called from a thread, will (atomic operation) :
- Stop other threads from accessing (locking)
- Read the last value from the main memory
- Increment it by 1
- Write the new value in shared memory
Testing
(Same as above)
@Test
public void test2() throws InterruptedException {
ExecutorService service = Executors.newFixedThreadPool(3);
SynchronizationWithAtomicClasses syncWithAtomic = new SynchronizationWithAtomicClasses();
IntStream.range(0, 1000).forEach(count -> service.execute(syncWithAtomic::incrementBy1));
shutdownAndAwaitTermination(service);
assertEquals(1000, syncWithAtomic.getValue());
}
Result: Success
