Thread Part I -Main Thread, Child thread and Method for Creating Thread

 Thread Part I
Main Thread, Child thread and Method for Creating Thread

Thread is part of program which is independent and can be run simultaneous, it mean a thread can be paused without to stop whole program. Every thread in java is inheritance from thread class in package java.lang. When we run java program in our program there will be at least one thread, this thread named main thread and the other thread named child thread .Let’s see how there is at least one thread in every time we run java program.

Here the full code :

public class MainThreadDemo {

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

  // retrieve the active thread

     Thread mainThread = Thread.currentThread();

     System.out.println("the default thread name :");

     System.out.println(mainThread.toString());

   // changing default thread name

     mainThread.setName("Main Thread");

     System.out.println("retrieve the new name for thread :");

     System.out.println(mainThread.toString());

     System.out.println("example for controlling thread");

     for (int i = 0; i < 5; i++) {

       System.out.println("delay..."+(i+1));

       Thread.sleep(1000);

     }

   }

}

the output when retrieving the default thread name
Thread[main,5,main] → [thread name, priority, group]
as how above that is the out format when we try current thread, main was the name of thread, the thread priority value is 5 and the group name is main.

For creating thread or child thread there are two method, first using interface and implements to the class that we made for thread,

public class MyRunnable implements Runnable{

@Override

   public void run() {

    System.out.println("the child thread is executed...");

   }

}

for running thread show bellow

public class MyRunnableDemo {

  public static void main(String[] args) {

    MyRunnable myRunnable = new MyRunnable();

    Thread thread = new Thread(myRunnable);

    thread.start();

    System.out.println("the main thread is executed...");

   }

}

if we run the result show bellow,

the main thread is executed...

the child thread is executed...

both method for running the thread we must call method start from thread itself, then automatic call run method for thread. We saw that the output both thread show that the program will execute main thread first and then the child thread.

Perhaps we confuse which one we should use, its depend on what you need, if we see in design side using interface is the best one, and also it is fit, if we just need runnable method only without override the from thread class, but if you need to modify every method in thread class extends thread class is the best way.

Thread Part III - Method isAlive and Join

Thread Part III

Method isAlive and Join

Sometime in our program we want our main thread be the last one to stop or finish, after all the child threads finished. For making this happen, firstly we need to check weather the child threads is alive using method isAlive(), then we use method join(), that belong to Thread Class. let’s check how it work first we create thread. As shown below,

public class MyThreadMain implements Runnable {

  private Thread thread;

  private int n;

  MyThreadMain(String name, int n){

   thread = new Thread(this, name);

   this.n = n;

  }

@Override

  public void run() {

  try {

    for (int i = 0; i <n; i++) {

System.out.println("Thread"+ thread.getName() +"second: "+(i+1));

  Thread.sleep(1000);

   }

System.out.println("Thread "+ thread.getName() +" finish.... ");

} catch (Exception e) {

   e.printStackTrace();

   }

}

   public void start(){

     thread.start();

   }

   public Thread getThread(){

     return thread;

   }

}

Now we try to make a few threads running together

public class IsAliveJoinDemo {

public stati cvoid main(String[]args)throws InterruptedException{

   System.out.println("\nMain Thread execute....");

   MyThreadMain t1 = new MyThreadMain("first", 2);

   MyThreadMain t2 = new MyThreadMain("second", 3);

   MyThreadMain t3 = new MyThreadMain("third", 3);

   t1.start();

   t2.start();

   t3.start();

  System.out.println("t1 is alive ? "+ t1.getThread().isAlive());

  System.out.println("t2 is alive ?"+ t2.getThread().isAlive());

  System.out.println("t3 is alive ?"+ t3.getThread().isAlive());

  t1.getThread().join();

  t2.getThread().join();

  t3.getThread().join();

  System.out.println("t1 is alive ? "+ t1.getThread().isAlive());

  System.out.println("t2 is alive ?"+ t2.getThread().isAlive());

  System.out.println("t3 is alive ?"+ t3.getThread().isAlive());

  System.out.println("\nMain Thread is executed..");

  }

}

if we run our code above the console will show below,

Main Thread execute....

t1 is alive ? true

Thread first second : 1

Thread second second : 1

Thread third second : 1

t2 is alive ?true

t3 is alive ?true

Thread third second : 2

Thread second second : 2

Thread first second : 2

Thread second second : 3

Thread third second : 3

Thread first finish....

Thread third finish....

Thread second finish....

t1 is alive ? false

t2 is alive ?false

t3 is alive ?false

Main Thread is executed..

as we saw for the result ,the main thread will be the last to finish after all the child threads is executed.