There are multiple ways to implement threading in Java. The first that we will try involves extending the Thread class. In Java, there is a built-in class that handles threads: java.lang.Thread. To create a thread, you create a class that extends the built-in Thread class and then overrides its public void run() method. Beyond these two requirements, the rest of your class can have anything you want in it!

The public void run() method that you override performs the actual work that your thread should be responsible for. This may be performing a long-running computation, calling out to another application or service, or other tasks that involve some waiting.

When you’ve defined your class in this way, you can then create an instance of your class in any other part of your program and call .start() on the instance to trigger the thread’s execution.

Here’s an example of a sequential program in Java that computes the meaning of life:

public class HugeProblemSolver {

  private static void solveComputation() {
    // Solves random computation
    // Takes anywhere from 1 second to 10 minutes
    System.out.println("The answer is: 42");
  }

  public static void main(String[] args) {
    HugeProblemSolver.solveComputation();
    HugeProblemSolver.solveComputation();
  }
}

In this program, we will only see the answer to the second question after the first question has been answered. A threaded solution would allow us to start the computations at the same time, and receive the answers as soon as they are available.

Let’s take a look at the threaded approach:

public class HugeProblemSolver extends Thread {

  private static void solveComputation() {
    // Solves random computation
    // Takes anywhere from 1 second to 10 minutes
  }

  @Override
  public void run() {
    solveComputation();
    System.out.println("The answer is: 42");
  }

  public static void main(String[] args) {
    HugeProblemSolver m1 = new HugeProblemSolver();
    HugeProblemSolver m2 = new HugeProblemSolver();
    m1.start();
    m2.start();
  }
}

Now, you can see that all that changed was:

• Extended the Thread Class
• Created and Overrode a .run() method from Thread
• Instantiated HugeProblemSolver and called .start() which signifies to start a new thread and search in the class for the .run() method to execute.

Now, both Threads we created are working on solving their own problems simultaneouly. Whichever one finishes first will print to the console first, no need to wait on sequential order.

Let’s see how we can implement this in our CrystalBall class.