Java Concurrency: Data, Resource Sharing and Thread Pools

import java.util.ArrayList;
import java.util.List;

public class A3_RaceConditions {
    public static void main(String[] args) throws InterruptedException {
        List<Thread> threads = new ArrayList<>();

        // Creating 10 "IncrementerTask" threads and starting them
        IncrementalData incrementalData = new IncrementalData();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new IncrementerTask(incrementalData));
            thread.start();
            threads.add(thread);
        }

        // Wait until all threads are finished
        for (Thread thread : threads) {
            thread.join();
        }

        // Lets Check the final result
        System.out.println("Result value: " + incrementalData.getValue());
    }

    public static class IncrementerTask implements Runnable {
        private IncrementalData incrementalData;

        public IncrementerTask(IncrementalData incrementalData) {
            this.incrementalData = incrementalData;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                incrementalData.increment();
            }
        }
    }

    public static class IncrementalData {
        private int value = 0;

        // The critical section
        public void increment() {
            // Read current value and add 1 to it
            this.value = value + 1;
        }

        public int getValue() {
            return value;
        }
    }
}

// 1. synchronized block on this
synchronized(this) {
  this.value = value + 1;
}

// 2. synchronized method:
public synchronized void increment() {
  this.value = value + 1;
}
// Following blocks of code 1 and 2 are practically equivalent.
// Even though the bytecode seems to be different, they do the same

class MyClass {
    public static void bar() {
        synchronized(MyClass.class) {
            doSomeOtherStuff();
        }
    }
}
// For static synchronized method these two blocks has same effect
class MyClass {
    public static synchronized void bar() {
        doSomeOtherStuff();
    }
}
// Following blocks of code 1 and 2 are practically equivalent.
// Even though the bytecode seems to be different, they do the same

public void bar(){
    synchronized(this){ // thread already owns the lock and it is reentrant
        ...
    }
}
//
public void foo(){
    synchronized(this){
        bar();
    }
}

import java.util.ArrayList;
import java.util.List;

public class A3_SynchronizationLocks {

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threads = new ArrayList<>();

        // GenericSavingFund instance for Client Bank-A
        GenericSavingFund arcSavingFund = new GenericSavingFund();
        GenericSavingFund flSavingFund = new GenericSavingFund();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new FundingClients(arcSavingFund));
            thread.setName("Thread ArcSavingFund");
            thread.start();

            Thread thread2 = new Thread(new FundingClients(flSavingFund));
            thread2.setName("Thread FLSavingFund");
            thread2.start();

            threads.add(thread);
        }


        // Wait until all threads are finished
        for (Thread thread : threads) {
            thread.join();
        }

        // Lets Check the final result
        arcSavingFund.getDetails();
        System.out.println("------------");
        flSavingFund.getDetails();
    }

    public static class FundingClients implements Runnable {

        private GenericSavingFund genericSavingFund;

        public FundingClients(GenericSavingFund genericSavingFund) {
            this.genericSavingFund = genericSavingFund;
        }

        @Override
        public void run() {

            for (int i = 0; i < 10000; i++) {
                genericSavingFund.increaseSavingBalance();
                double random = Math.random();
                if( random > 0.95){
                    genericSavingFund.increaseMaturity();
                }
            }

        }
    }

    public static class GenericSavingFund {

        private int savingBalance = 0;
        private int maturityYears = 1;
        private static final int POLICY_MAX_MATURITY_YEARS = 25;

        private Object lock1 = new Object();
        private Object lock2 = new Object();

        public void increaseSavingBalance() {
            synchronized (lock1) {
                System.out.println(Thread.currentThread().getName() + "Increasing current balance from " + savingBalance);
                savingBalance = savingBalance + 5;
            }
        }

        public void increaseMaturity() {
            synchronized (lock2) {
                System.out.println(Thread.currentThread().getName() + "Increasing current maturity from "+ maturityYears);
                if (maturityYears < POLICY_MAX_MATURITY_YEARS) {
                    maturityYears++;
                }
            }
        }

        public void getDetails() {
            System.out.println("Total Max maturity Year: " + POLICY_MAX_MATURITY_YEARS);
            System.out.println("You completed " + maturityYears + " maturity years");
            long remainingYears = (long) POLICY_MAX_MATURITY_YEARS - maturityYears;
            String response = remainingYears==0 ? "Your balance is ready:" + savingBalance : "Please wait some years: " + remainingYears;
            System.out.println(response);
        }

    }
}

#output
Total Max maturity Year: 25
You completed 25 maturity years
Your balance is ready: 500000