public class MainClass {

    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.println("My name is: " + Thread.currentThread().getName());
        System.out.println("My id is: "+ Thread.currentThread().getId());
    }
}

Hello World
My name is: main
My id is: 1

public class A1_ThreadCreation {

    public static void main(String[] args) {
        System.out.println("01. Java Concurrency -- Thread Creation");

        // 1. Extends Thread
        HelloThread helloThread = new HelloThread();
        helloThread.start();

        // 2. Implements Runnable
        HelloThreadTwo helloThreadTwo = new HelloThreadTwo();
        Thread threadRunnable = new Thread(helloThreadTwo);
        threadRunnable.start();

        // Another common approach:
        // Passing Anonymous Runnable Object to Thread constructor
        Thread threadAnonymous = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from thread created Using Anonymous Runnable Object");
            }
        });
        threadAnonymous.start();

        // Using a lambda (functional interface)
        Thread threadLambda = new Thread(() -> System.out.println("Hello from thread created Using Functional Interface"));
        threadLambda.start();
    }
}

    // 1. Extending Thread Class
    public static class HelloThread extends Thread {

        @Override
        public void run() {
            System.out.println("Hello from a Extends Thread implementation!");
        }

    }

    // 2. Implementing Runnable Interface
    public static class HelloThreadTwo implements Runnable {

        @Override
        public void run() {
            System.out.println("Hello from a Runnable thread Implementation!");
        }

    }

01. Java Concurrency -- Thread Creation
Hello from a Extends Thread implementation!
Hello from a Runnable thread Implementation!
Hello from thread created Using Anonymous Runnable Object
Hello from thread created Using Functional Interface

public class A2_ThreadInterrupts {

    public static void main(String[] args) throws InterruptedException {

        SomeTask someTask = new SomeTask();
        Thread threadSomeTask = new Thread(someTask);

        // If you want the thread to stop when the main thread stops, set it as a daemon:
        // threadSomeTask.setDaemon(true);

        threadSomeTask.start();

        /**
         * Let’s wait 3 seconds in the main thread, then interrupt "threadSomeTask".
         * main thread -> sleeps -> calls interrupt() on someTask’s thread
         */
        Thread.sleep(3000);
        threadSomeTask.interrupt();

        // --------------------------------------------------------------------------------

        LongProcessingTask longProcessingTask = new LongProcessingTask();
        Thread threadLongProcessing = new Thread(longProcessingTask);
        threadLongProcessing.start();

        /**
         * Immediately call interrupt on the second thread.
         * The actual interruption depends on whether and when
         * the thread checks 'Thread.interrupted()' or hits sleep().
         */
        threadLongProcessing.interrupt();
    }

    public static class SomeTask implements Runnable {

        @Override
        public void run() {
            System.out.println("----------- SomeTask ---------------");
            System.out.println("Executing some task in background ");

            try {
                System.out.println("Performing some operation. May take 10-20 Seconds !!!");
                Thread.sleep(10000);
                System.out.println("This task is executed after waiting for 10 seconds");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static class LongProcessingTask implements Runnable {

        @Override
        public void run() {

            System.out.println("----------- LongProcessingTask ---------------");
            System.out.println("I cant be interrupted. ( Need some conditions to stop the flow and 'Scheduled me out' ). ");
            while (true) {
                System.out.println("... I am performing Infinite sout ... ");

                // This thread checks interrupt status:
                if (Thread.interrupted()) {
                    System.out.println("Condition Met !!! I am interrupted.");
                    // Perform any cleanup if needed
                    return;
                }
            }
        }
    }
}

public class A2_ThreadMethods {

    public static void main(String[] args) throws InterruptedException {
        /**
         * Inter-thread communication – see thread methods: join(), wait(), notify().
         *
         * Scenario:
         * 1) Send an SMS to a friend,
         * 2) Only after it's sent, check the phone balance.
         */

        AccountInfo accountInfo = new AccountInfo("CodeGrave", 200);

        // Threads
        SendSMS sendSMS = new SendSMS(accountInfo);
        Thread smsThread = new Thread(sendSMS);

        CheckPhoneBalance checkPhoneBalance = new CheckPhoneBalance(accountInfo);
        Thread checkBalance = new Thread(checkPhoneBalance);

        // Start SMS thread, then use join() to wait until it finishes
        smsThread.start();
        smsThread.join();

        // After SMS sending is done, check the balance
        checkBalance.start();
        checkBalance.join();
    }

    public static class SendSMS implements Runnable {
        private AccountInfo accountInfo;
        public SendSMS(AccountInfo accountInfo) {
            this.accountInfo = accountInfo;
        }

        @Override
        public void run() {
            System.out.println("----------- SendSMS ---------------");
            try {
                System.out.println("Sending SMS");
                Thread.sleep(5000);
                accountInfo.decreaseBalance(2); // SMS cost: $2
                System.out.println("SMS successfully sent to friend Rearc - 000-000-0000");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static class CheckPhoneBalance implements Runnable {
        private AccountInfo accountInfo;
        public CheckPhoneBalance(AccountInfo accountInfo) {
            this.accountInfo = accountInfo;
        }

        @Override
        public void run() {
            System.out.println("----------- CheckPhoneBalance ---------------");
            try {
                System.out.println("Retrieving Phone Balance");
                Thread.sleep(500);
                System.out.println("Your remaining balance is: " + accountInfo.getCurrentBalance());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static class AccountInfo {
        private String accountHolderName;
        private int currentBalance;

        public AccountInfo(String accountHolderName, int currentBalance) {
            this.accountHolderName = accountHolderName;
            this.currentBalance = currentBalance;
        }

        public int getCurrentBalance(){
            return this.currentBalance;
        }

        public void decreaseBalance(int am){
            this.currentBalance -= am;
        }
    }
}

----------- SendSMS ---------------
Sending SMS
----------- CheckPhoneBalance ---------------
Retrieving Phone Balance
Your remaining balance is: 200  # Even though we call send SMS , our balance is still 200 ?

SMS successfully send to friend Rearc - 000-000-0000 # Since SMS takes some time, we need to wait .

# How can we make the main thread wait after invoking send SMS thread? >> We do by join().

----------- SendSMS ---------------
Sending SMS
SMS successfully send to friend Rearc - 000-000-0000
----------- CheckPhoneBalance ---------------
Retrieving Phone Balance
Your remaining balance is: 198 # As expected, the balance was decreased after the SMS was sent.