public class Main extends Thread {
public static int amount = 0;
public static void main(String[] args) {
Main thread = new Main();
thread.start();
// Wait for the thread to finish
while(thread.isAlive()) {
System.out.println("Waiting...");
}
// Update amount and print its value
System.out.println("Main: " + amount);
amount++;
System.out.println("Main: " + amount);
}
public void run() {
amount++;
}
}
Here's what's happening:
isAlive() just returns true or false based on whether the thread is alive or not. Since your thread is only incrementing the value of `amount` exactly once, the thread does not live for long. Once it finishes executing all lines of code in the `run()` method, the thread terminates immediately, that is why it prints "Waiting..." twice because it terminates quickly. You can get the thread to be alive longer by calling a `Thread.sleep()` method in your `run()` method. This will result in many more "Waiting..." messages to be printed.
The above example is demonstrating that you can increment the value of `amount` in parallel. Though it is not a very good example.
It allows you to run things in parallel. For example, if you were to create a UI application in a single thread, you would not want the whole application to freeze if you want to trigger some long running job. In this case, you run the job in a separate thread and let your UI application run in the main thread. This way your UI application does not freeze and the job goes on in the background.
Consider this code:
package come.desmonddavid.ThreadTest;
public class ThreadTest {
public static void main(String[] args) {
Runnable r = () -> {
System.out.println("Starting thread "+Thread.currentThread().getId());
for(int i = 0; i < 10; i++) {
long sleepTime = 1000L;
try {
System.out.println(Thread.currentThread().getId()+": Sleeping for "+sleepTime+" milliseconds");
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Exiting thread "+Thread.currentThread().getId());
};
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.start();
t2.start();
t3.start();
}
}Starting thread 11
11: Sleeping for 1000 milliseconds
Starting thread 13
Starting thread 12
12: Sleeping for 1000 milliseconds
13: Sleeping for 1000 milliseconds
12: Sleeping for 1000 milliseconds
11: Sleeping for 1000 milliseconds
13: Sleeping for 1000 milliseconds
13: Sleeping for 1000 milliseconds
12: Sleeping for 1000 milliseconds
11: Sleeping for 1000 milliseconds
11: Sleeping for 1000 milliseconds
13: Sleeping for 1000 milliseconds
12: Sleeping for 1000 milliseconds
11: Sleeping for 1000 milliseconds
12: Sleeping for 1000 milliseconds
13: Sleeping for 1000 milliseconds
Exiting thread 11
Exiting thread 13
Exiting thread 12Threads can also make your code very complicated by potentially introducing problems such as race conditions, deadlocks, ConcurrentModificationExceptions, etc. So, you have to be very careful when using Threads. You should read up about thread safety in Java to see why this is important.
Extending a Thread class may be beneficial in case when you already have some Thread functionality defined either as an abstract class or an existing concrete class and you need to enhance it's functionality. This however is a very special case and for most cases you will not need to extend a thread class since you simply need to run some piece of code. In this latter case, implementing a Runnable is simpler and thus preferable over extending a Thread class.
What is ADT?
package come.desmonddavid.ThreadTest;
public class MessagePassingTest {
public static void main(String[] args) throws InterruptedException {
SquareThread st = new SquareThread();
st.start();
Thread.sleep(1000);
st.feedValue(2);
Thread.sleep(1000);
st.feedValue(4);
Thread.sleep(1000);
st.feedValue(10);
Thread.sleep(1000);
st.quit();
}
}
class SquareThread extends Thread {
private volatile boolean valChanged = false;
private volatile boolean quitThread = false;
private volatile int value = 0;
@Override
public void run() {
System.out.println("Starting SquareThread");
while(true) {
if(quitThread) {
System.out.println("Exiting SquareThread");
return;
}
if(valChanged) {
System.out.println("Square of " + value + " is " + value * value);
valChanged = false;
}
}
}
public void feedValue(int value) {
this.value = value;
valChanged = true;
}
public void quit() {
quitThread = true;
}
}feedValue() method, waiting 1 second between feeding values three times. After than the main() method calls quit() and that terminates the thread. This is a very simple example, so I think you should be able to understand just by looking at it. If you have any doubts, then ask here.
Sorry, that was a force of habit. We use Java 8 at work, so I have developed a habit of using lambdas.
Runnable r = () -> {} is equivalent to:Runnable r = new Runnable() {
public void run() {
// Do something
}
}Because Thread has multiple overloaded constructors, one of them takes a Runnable as an argument. Reference: Thread (Java Platform SE 8 )
I still take reference from Baeldung, and I have over 9 years of experience working in software development.
I think they are okay for beginners.