Understand the idea

A thread can execute independently of the calling thread. start schedules a new thread; calling run directly is just a normal method call on the current thread. Use join when the caller must wait for completion. Real shared-state work also needs correct synchronization.

Explore the details

Java Threads

Threads allows a program to operate more efficiently by doing multiple things at the same time.

Threads can be used to perform complicated tasks in the background without interrupting the main program.

Creating a Thread

There are two ways to create a thread.

It can be created by extending the Thread class and overriding its run() method:

Another way to create a thread is to implement the Runnable interface:

Running Threads

If the class extends the Thread class, the thread can be run by creating an instance of the class and call its start() method:

If the class implements the Runnable interface, the thread can be run by passing an instance of the class to a Thread object's constructor and then calling the thread's start() method:

Concurrency Problems

Because threads run at the same time as other parts of the program, there is no way to know in which order the code will run. When the threads and main program are reading and writing the same variables, the values are unpredictable. The problems that result from this are called concurrency problems.

Three Ways to Create a Thread

// Way 1 — Extend Thread class
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + getName());
    }
}
new MyThread().start();

// Way 2 — Implement Runnable (preferred — allows extending other classes)
class MyTask implements Runnable {
    public void run() {
        System.out.println("Runnable running: " + Thread.currentThread().getName());
    }
}
new Thread(new MyTask()).start();

// Way 3 — Lambda (Java 8+, most concise)
new Thread(() -> System.out.println("Lambda thread!")).start();

Thread Lifecycle

To avoid concurrency problems, it is best to share as few attributes between threads as possible. If attributes need to be shared, one possible solution is to use the isAlive() method of the thread to check whether the thread has finished running before using any attributes that the thread can change.

A complete runnable example

This complete Main.java program focuses on the lesson idea. Reference fragments above may demonstrate individual statements; this example includes the imports, entry point, and supporting types it needs.

public class Main {
    public static void main(String[] args) throws Exception {
        Thread worker = new Thread(() -> System.out.println("Worker finished"));
        worker.start();
        worker.join();
        System.out.println("Main continues");
    }
}

Worker finished
Main continues

Change it. Run it. Understand it.

Load this lesson example into the editor. Change one value or statement, predict the result, then press RUN to execute Java.

Make it your own

Your learning checkpoint

• Explain the example without reading the output first.
• Make the change requested in the practice task.
• Describe why the result changed—or why compilation failed.

Ready to move on? Follow the next lesson in course order, or return to the curriculum to review a prerequisite.