Threads in Java

Submitted by pavel7_7_7 on Monday, September 1, 2014 - 10:47.

Multithreading application are really powerful applications. These applications can solve multiple tasks in the same time. Java programming language offers a good and flexible mechanism for using threads in your programs. There are two possibilities to create your own threads: the first way is to implement interface Runnable and the second way is to extend class Thread. I'll show you the both variants. The interface Runnable consists of one method:

public interface Runnable {    
        public abstract void run();
}

So, to create a thread class you need to override the run() method. I'll show you an example of a thread, that will show messages with a specified interval of time:

public class RunnableThread implements Runnable

The members of this class are:

Thread myThread;
int sleep_time;
String Tname;

We need to have a thread object in the class to start your own thread. The constructor of the class is presented here:

RunnableThread(String name, int _sleep_time){
                sleep_time = _sleep_time;
                Tname= name;
                myThread = new Thread(this,name);
                System.out.println("New thread created "+myThread);
                myThread.start();
        }

In the constructor start() method is called. This method calls the method run() that must be overridden:

@Override
        public void run() {
                // TODO Auto-generated method stub
                try{
                        for (int i = 10; i > 0; --i){
                                System.out.println(myThread+" "+i);
                                myThread.sleep(sleep_time);
                        }
                }
                catch(InterruptedException e){
                        System.out.println(myThread+" interrupted");
                }
                System.out.println(myThread+" terminated");
        }

Also, in this class there is a method, used to set the priority of the thread:

public void setPriority(int p){
                myThread.setPriority(p);
        }       

The second way of extending the Thread class consist of defining additional properties to the base class:

public class ThreadExt extends Thread

Now, you can add any feature you want. I did it in the simple way by adding a message to be shown in the constructor after calling the constructor of the super class:

ThreadExt(String _name){
        super(_name);
        System.out.println(_name+" "+this);
        start();        
}

The method run is defined similarly to the way I did it in the first case:

public void run(){
                try{
                        for (int i = 10; i > 0; --i){
                                System.out.println(this+" "+i);
                                Thread.sleep(300);
                        }
                }
                catch(InterruptedException e){
                        System.out.println(this+" interrupted");
                }
                System.out.println(this+" terminated");
        }

It shows a message with the interval of 300 milliseconds. Now we can test both methods. Let's create three thread object in the public static void main() method:

RunnableThread t1 = new RunnableThread("First",500);
RunnableThread t2 = new RunnableThread("Second",100);
ThreadExt t3 = new ThreadExt("Third");

Now we can set different priorities to the objects:

t1.setPriority(1);
t1.setPriority(10);
t3.setPriority(4);

I wan't to show the priorities of all threads only after all the threads are terminated.That's why I'm using join() method to wait for thread termination in main thread:

System.out.println("Waiting for threads termination");
                try{
                        t1.myThread.join();
                        t2.myThread.join();
                        t3.join();
                }
                catch(InterruptedException e){
                        System.out.println("Main thread terminated");
                }

Join method can throw InterruptedException if the main thread is interrupted. So a try/catch block is necessary here. Now I can show the priority of all threads:

System.out.println("Priority of the first thread was "+t1.myThread.getPriority());
                System.out.println("Priority of the second thread was "+t2.myThread.getPriority());
                System.out.println("Priority of the third thread was "+t3.getPriority());

The output of this program is:

New thread created Thread[First,5,main]
New thread created Thread[Second,5,main]
Thread[First,5,main] 10
Thread[Second,5,main] 10
Third Thread[Third,5,main]
Waiting for threads termination
Thread[Third,4,main] 10
Thread[Second,5,main] 9
Thread[Second,5,main] 8
Thread[Second,5,main] 7
Thread[Third,4,main] 9
Thread[Second,5,main] 6
Thread[First,10,main] 9
Thread[Second,5,main] 5
Thread[Second,5,main] 4
Thread[Third,4,main] 8
Thread[Second,5,main] 3
Thread[Second,5,main] 2
Thread[Second,5,main] 1
Thread[Third,4,main] 7
Thread[First,10,main] 8
Thread[Second,5,main] terminated
Thread[Third,4,main] 6
Thread[First,10,main] 7
Thread[Third,4,main] 5
Thread[First,10,main] 6
Thread[Third,4,main] 4
Thread[Third,4,main] 3
Thread[First,10,main] 5
Thread[Third,4,main] 2
Thread[First,10,main] 4
Thread[Third,4,main] 1
Thread[Third,4,main] terminated
Thread[First,10,main] 3
Thread[First,10,main] 2
Thread[First,10,main] 1
Thread[First,10,main] terminated
Priority of the first thread was 10
Priority of the second thread was 5
Priority of the third thread was 4

The output of this program will be different on different pc. This is a simple tutorial about threads, but I hope, it can help you to understand more difficult thing. The whole eclipse project is attached, so you can review it.

Add new comment

15 views