feat: implement synchronized ATM access with multiple customers

WHAT the code does:
- Defines an ATM class with two synchronized methods:
  - checkBalance() simulates balance inquiry with delay.
  - withdraw() simulates cash withdrawal with delay.
- Customer class extends Thread:
  - Holds name, amount, and ATM reference.
  - Overrides run() to perform both checkBalance() and withdraw().
- ATMMoney main class:
  - Creates one ATM instance.
  - Spawns two Customer threads (Smith and John) using the same ATM.
  - Starts both threads to simulate concurrent ATM usage.

WHY this matters:
- Demonstrates synchronization in Java to prevent race conditions when multiple threads access shared resources.
- Shows how synchronized methods ensure only one thread executes ATM operations at a time.
- Models a real-world case where multiple customers safely share a single ATM.

HOW it works:
1. ATM methods declared synchronized → implicit lock on ATM instance.
2. Each Customer thread executes useATM():
   - First checks balance.
   - Then withdraws specified amount.
3. Thread.sleep() simulates time delay (like processing transactions).
4. Because of synchronization:
   - While one customer uses ATM, the other must wait.
   - Prevents inconsistent or interleaved outputs.

Key points:
- `synchronized` ensures mutual exclusion.
- Threads share one ATM instance → critical section protection.
- Thread lifecycle: start() → run() → terminated.

Short key: java-threads synchronized-atm-multithreading demo.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section19MultiThreading/src/ATMMoney.java

@@ -1,16 +1,13 @@
-class ATM
-{
-    synchronized public void checkBalance(String name)
-    {
+class ATM {
+    synchronized public void checkBalance(String name) {
         System.out.println(name+" Checking ");
 
         try{Thread.sleep(1000);}catch (Exception e){}
 
-        System.out.println("Balance is");
+        System.out.println("Balance is: ");
     }
 
-    synchronized public void withdraw(String name, int amount)
-    {
+    synchronized public void withdraw(String name, int amount) {
         System.out.println(name+" withdrawing ");
 
         try{Thread.sleep(1000);}catch (Exception e){}
@@ -19,35 +16,32 @@ synchronized public void withdraw(String name, int amount)
     }
 }
 
-class Customer extends Thread
-{
+class Customer extends Thread {
     String name;
     int amount;
 
-    ATM atm; //Reference to the ATM
-    Customer(String n, ATM a, int amt) //prameterized constructor and properties are initialized.
+    ATM atm; //Reference to the ATM.
+    Customer(String n, ATM a, int amt) //parameterized constructor and properties are initialized.
     {
         name=n;
         atm=a;
         amount=amt;
     }
 
     //Method call.
-    public void useATM()
-    {
+    public void useATM() {
         atm.checkBalance(name);
         atm.withdraw(name, amount);
     }
-    public void run() //Must override to acheive MultiThreading
+
+    public void run() //Must override to achieve MultiThreading.
     {
         useATM();
     }
 }
 
-public class ATMMoney
-{
-    public static void main(String[] args)
-    {
+public class ATMMoney {
+    public static void main(String[] args) {
         ATM atm = new ATM();
 
         Customer c1=new Customer("Smith", atm,100);
@@ -56,4 +50,4 @@ public static void main(String[] args)
         c1.start();
         c2.start();
     }
-}
+}