How are java threads created?

Answer 1

Thread can be created in two ways either by extending Thread or implementing runnable interface

Examples:

public class A extends Thread { } public class A implements Runnable { } By using both the methods we can create a Java Thread. The disadvantage of extending the Thread class is that, you cannot extend the features of any other class. If we extend the Thread class we cannot extend any other class whose features we may require in this class.

So it is usually advisable to implement the Runnable Interface so that we can extend the required features and at the same time use the Thread functionality.

Answer 2

There are two ways to create a thread. The first is to declare a class that extends the Thread object. When the class is instantiated, the thread and object are created together and the object is automatically bound to the thread. By calling the object's start() method, the thread is started and immediately calls the object's run() method.

Ex:

// This class extends Thread

class TestThread extends Thread {

// This method is called when the thread runs

public void run() {

}

}

// Create and start the thread

Thread thread = new TestThread();

thread.start();

The second way is to implement the Runnable interface.

Ex:

class TestThread2 implements Runnable {

// This method is called when the thread runs

public void run() {

}

}

// Create the object with the run() method

Runnable runnable = new TestThread2();

// Create the thread supplying it with the runnable object

Thread thread = new Thread(runnable);

// Start the thread

thread.start();

Answer 3

// Create a thread
Thread myThread = new Thread{
public void run() {

System.out.println("You ran this thread by calling Thread.start()!");

}

};

// Tell Java to start the thread
myThread.start();

Note that you can simply call myThread.run(), but this will NOT create a new thread. It will simply execute the code in the thread's run method inside of the current thread.

Answer 4

You can define and instantiate a thread in one of two ways:

• Extend the java.lang.Thread class.

• Implement the Runnable interface.

Ex1:

class MyFirstThread extends Thread {

public void run() {

System.out.println("Important job running in MyFirstThread");

}

}

Ex2:

class MyFirstRunnableClass implements Runnable {

public void run() {

System.out.println("Imp job running in MyFirstRunnableClass");

}

}

Answer 5

To define a thread, you need a place to put your run() method, and as we just discussed, you can do that by extending the Thread class or by implementing the Runnable interface. We'll look at both in this section.

Extending java.lang.Thread

The simplest way to define code to run in a separate thread is to

• Extend the java.lang.Thread class.

• Override the run() method.

It looks like this:

class MyFirstThread extends Thread {

public void run() {

System.out.println("Important job running in MyFirstThread");

}

}

The limitation with this approach is that if you extend Thread, you can't extend anything else. And it's not as if you really need that inherited Thread class behavior, because in order to use a thread you'll need to instantiate one anyway.

Keep in mind that you're free to overload the run() method in your Thread subclass:

class MyFirstThread extends Thread {

public void run() {

System.out.println("Important job running in MyFirstThread");

}

public void run(String s) {

System.out.println("String running is " + s);

}

}

Note: The overloaded run(String s) method will be ignored by the Thread class unless you call it yourself. The Thread class expects a run() method with no arguments, and it will execute this method for you in a separate call stack after the thread has been started. With a run(String s) method, the Thread class won't call the method for you, and even if you call the method directly yourself, execution won't happen in a new thread of execution with a separate call stack. It will just happen in the same call stack as the code that you made the call from, just like any other normal method call.

Implementing java.lang.Runnable

Implementing the Runnable interface gives you a way to extend any class you like, but still define behavior that will be run by a separate thread. It looks like this:

class MyFirstRunnableClass implements Runnable {

public void run() {

System.out.println("Imp job running in MyFirstRunnableClass");

}

}

Regardless of which mechanism you choose, you've now got yourself some code that can be run by a thread of execution. So now let's take a look at instantiating your thread-capable class, and then we'll figure out how to actually get the thing running.

Answer 6

It is a Process which is running continuously until it ends or we stops or pause.for an example media players.these are running on basis of thread concepts.