Social networks
You can find me on:
   
Open sharing content

These articles are available under Creative Commons license BY-SA-3.0

Posts Tagged ‘threads’

The thread class provides some methods to define the threads behavior.
Two important methods to consider are:
join(), to make the other instanced threads to wait for it to day. You can provide a timeout as parameter.
sleep();

The sleep() method throws a checked exception called “InterruptedException”,each time the thread receives an interrupt request. You have to handle in the code by wrapping the method in a try-catch block.

The following code will make you understand the join method.
We define a MyThread thread:

public class MyThread implements Runnable {

	public void run() {
		Thread thread= Thread.currentThread();
		System.out.println("Implementing the runnable interface"
				+ " - Thread name: " + thread.getName()
				+ " - priority: " + thread.getPriority()
				+ " - group: " + thread.getThreadGroup().getName());

	}

}

Then we can observe the behaviour running the following main:

		public static void main(String[] args) {

		// extending Thread
		Thread myThread = new Thread(new MyThread());
		Thread myJoiningThread = new Thread(new MyThread());

		myThread.setName("myThread");
		myJoiningThread.setName("myJoiningThread");

		System.out.println("Threads will be started...");

		myJoiningThread.start();

		try {
			// waits for this thread to die
			myJoiningThread.join();
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		myThread.start();

	}

Without the try-catch block in which the join method is invoked the threads would be started asynchronously (the order is not predictable) and in the console you might get either:
Threads will be started...
Implementing the runnable interface - Thread name: myThread - priority: 5 - group: main
Implementing the runnable interface - Thread name: myJoiningThread - priority: 5 - group: main

or:

Threads will be started...
Implementing the runnable interface - Thread name: myJoiningThread - priority: 5 - group: main
Implementing the runnable interface - Thread name: myThread - priority: 5 - group: main

But if you include the try-catch block, the myJoiningThread will always be invoked first.

To understand the sleep method you can create a MySleepingThread:

public class MySleepingThread implements Runnable {

	public void run() {
		Thread thread= Thread.currentThread();
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("Implementing the runnable interface"
				+ " - Thread name: " + thread.getName()
				+ " - priority: " + thread.getPriority()
				+ " - group: " + thread.getThreadGroup().getName());

	}

}

Then you can run the following main method:

public static void main(String[] args) {

		// extending Thread
		Thread myThread = new Thread(new MyThread());
		Thread mySleepingThread = new Thread(new MySleepingThread());
		myThread.setName("myThread");
		mySleepingThread.setName("mySleepingThread");

		System.out.println("Threads will be started...");

		mySleepingThread.start();
		myThread.start();

	}

You can see in the console that the sleeping thread will be started after 3 seconds.

The sleep method is static. By invoking “Thread.sleep(3000)” you are delaying the creation of the current thread.

If you use the method in the main method, the sleeping thread will be “main”.

I am learning for the Java OCP 7 and summarizing some relevant infos about Multithreading.
For now I am referring to chapter 13 in the book by G.Ganesh.

You can create threads in 2 ways: extending the Thread class or implementing the Runnable interface
Extending the Thread class is more convenient if you don´t need to extend another class that is not “Thread” (since in java you can only extend one class), because you can use the class methods directly (like “getName()“).
If you implement the Runnable interface (preferred way because of inheritance) you will have to use the static method “currentThread()” of the Thread class to do your operations on the thread (like setting or getting the name).

The two fundamental methods to know are:
run(): like a main method, necessary to enable the execution of a thread.
start(): that creates the thread.

The thread will be terminated when the run method execution is complete. It´s invoked implicitly by the JVM (DON´T invoke it explicitly!).
The main method starts a Thread called “main“. If you create and start your own thread it will have default names like “Thread-0“, “Thread-1“.

If you extend the thread class you need to override the run() method (otherwise it does nothing). If you implement the Runnable interface you will have to implement the run() method (mandatory)

The following code will help you to understand more about these first concepts.

public class MyThread1 extends Thread {

	public void run() {
		System.out.println("Extending the Thread class - Thread name: "
				+ getName() + " - priority: " + getPriority() + " - group: "
				+ getThreadGroup().getName());

	}

}
public class MyThread2 implements Runnable {

	public void run() {
		Thread thread= Thread.currentThread();
		System.out.println("Implementing the runnable interface"
				+ " - Thread name: " + thread.getName()
				+ " - priority: " + thread.getPriority()
				+ " - group: " + thread.getThreadGroup().getName());

	}

}
public class ThreadsDemo {

	public static void main(String[] args) {

		// extending Thread
		Thread myThread1 = new MyThread1();
		// implementing Runnable
		Thread myThread2 = new Thread(new MyThread2());

		System.out.println("Threads defined. Default properties: ");
		//name, priority, group returned by the toString method 
		System.out.println(myThread1);
		System.out.println(myThread2);
		System.out.println("Changing default names...");
		myThread1.setName("Thread_1");
		myThread2.setName("Thread_2");
		System.out.println("Threads will be started...");
		myThread1.start();
		myThread2.start();

	}

}

The output of the main method should be something like:

Threads defined. Default properties:
Thread[Thread-0,5,main]
Thread[Thread-1,5,main]
Threads will be started...
Extending the Thread class - Thread name: Thread-0 - priority: 5 - group: main
Implementing the runnable interface - Thread name: Thread-1 - priority: 5 - group: main

Launching the main program you see that the threads are started asynchronously. Sometimes you see:
Implementing the runnable interface - Thread name: Thread-1
Extending the Thread class - Thread name: Thread-0

Sometimes it´s:
Extending the Thread class - Thread name: Thread-0
Implementing the runnable interface - Thread name: Thread-1

You can quickly proof it in Eclipse launching the program with the shortcut Ctlr+11.

To change this “random” behaviour you can set the priority with the setPriority() method, from 1, the lowest, to 10, the highest. The default is 5. They can be all retrieved by the static members:
– Thread.NORM_PRIORITY ;
– Thread.MAX_PRIORITY ;
– Thread.MIN_PRIORITY .

Threads can be in one of the following states:
– NEW (created)
– RUNNABLE (started)
– TERMINATED
– BLOCKED (waiting to acquire the lock)
– WAITING (waiting for notifications)
– TIMED_WAITING (sleep() invoked and the thread is sleeping or if wait() with timeout)

States are defined with the Thread.State enumeration.
You can get the state with the getState() method.