1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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());

        // output
        // Hello World
        // My name is: main
        // My id is: 1
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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 of thread creation you will often see, 
        // Passing Anonymous Runnable Object as an argument to thread
        Thread threadAnonymous = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from thread created Using Anonymous Runnable Object");
            }
        });
        threadAnonymous.start();

        // Another approach, Transforming above code into 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!");
        }

    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

public class A2_ThreadInterrupts {

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


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

        // Our thread "threadSomeTask" will continue running on background. So, if we want to stop it when main thread stops, attached it to daemon
        // threadSomeTask.setDaemon(true);

        threadSomeTask.start(); // start() method calls run(), in a new thread, if you directly call run() method then it wont me a new thread

        /**
         * Lets wait for 3 seconds and call `intrrupt()` to stop our thread
         *
         * We know that main thread runs as a thread itself, (so, mainthread is already running)
         * we also have already started our other thread "threadSomeTask" in the background.
         * so calling Thread.sleep() here will only pause our main thread
         */
        Thread.sleep(3000);
        threadSomeTask.interrupt();

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

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

        /**
         * Here interrupt will only work with conditions, interrupt can only schedule to stop the thread for the next coming cycle.
         * Previously, we did thread.sleep(), that "scheduled thread out".
         * And then calling interrupt method, marked it as not eligible for the context switches and was removed from scheduling queue; throwing "InterruptedException"
         */
        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 !!!");
                // sleep() method "Scheduled thread out" for a time being eg. 10 Second here (during this other task comes in),
                // After 10 seconds the thread scheduler, "Reschedules thread in" using context switches
                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 ... ");

                // Now, This thread can be stopped here, By checking if interrupt was called
                if (Thread.interrupted()) {
                    System.out.println("Condition Met !!! I am interrupted.");
                    // some task to carry out on an interruption
                    return;
                }
            }
        }
    }

}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

public class A2_ThreadMethods {

    public static void main(String[] args) throws InterruptedException {
        /**
         * Inter-thread communication- See thread methods: join(), wait()-notify().
         *
         * Lets send an SMS to our friend and then ony check our balance
         * Lets create a accountInfo first, it will hold "accountHolderName" and "currentBalance"
         */

        AccountInfo accountInfo = new AccountInfo("CodeGrave", 200);
        // Initializing thread - sendSMS and checkBalance
        SendSMS sendSMS = new SendSMS(accountInfo);
        Thread smsThread = new Thread(sendSMS);
        CheckPhoneBalance checkPhoneBalance = new CheckPhoneBalance(accountInfo);
        Thread checkBalance = new Thread(checkPhoneBalance);

        // Each thread have its own information and behaviours defined by java concurrency
        // eg - getId(), getPriority(), getName() etc.. and isAlive(), join(), sleep(), start() etc...
        // eg - smsThread.getId(), smsThread.getPriority(), ...... smsThread.sleep(), smsThread.start() ......

        // ----------------------------------------------------------------------------------
        // ------------------------ Starting and joining threads -----------------------------

        /**
         * join() method allows one thread to wait until another thread completes its execution.
         * (i.e wait until we complete sending SMS and then check balance)
         *
         * in the join() method, the calling thread goes into a waiting state, handing over the control
         * i.e the main thread goes into waiting state, handing over the control to "smsThread"
         */
        smsThread.start();
        smsThread.join(); // main thread hands over the control to sms thread
        // after smsThread completes its task, it returns control to the calling method or main thread here

        checkBalance.start();
        checkBalance.join();
    }

    public static class SendSMS implements Runnable {

        // Initializing AccountInfo
        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 send to friend Rearc - 9912345678");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static class CheckPhoneBalance implements Runnable {

        // Initializing AccountInfo
        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 = this.currentBalance - am;
        }
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Without using join()
----------- SendSMS ---------------
Sending SMS
----------- CheckPhoneBalance ---------------
Retrieving Phone Balance
Your remaining balance is: 200
SMS successfully send to friend Rearc - 9912345678
# Sending SMS took a long, i got the balance check faster 
# But now, we dont know how much SMS cost us.

# Using join
----------- SendSMS ---------------
Sending SMS
SMS successfully send to friend Rearc - 9812345678
----------- CheckPhoneBalance ---------------
Retrieving Phone Balance
Your remaining balance is: 198