Understanding Java Threads: A Comprehensive Guide

Understanding Java Threads: A Comprehensive Guide

1. 1. Program, Process and Thread Concepts
2. 2. Two Ways of Implementing Threads
   1. Extending Thread Class
   2. Implementing Runnable Interface
3. 3. Commonly Used Methods in Thread Class
4. 4. Synchronization in Java
   1. Synchronized Methods and Blocks
   2. wait(), notify() and notifyAll()
5. 5. Key Takeaways
6. 6. Conclusion
   1. References

Java threads enable concurrent execution, making applications more efficient and responsive. This guide covers the basics, implementation methods, key methods, synchronization, and concludes with key takeaways.

1. Program, Process and Thread Concepts

The distinction between program, process, and thread is fundamental to concurrent programming:

• A program is a set of instructions stored in a file, passive until executed, like notepad.exe for text editing.
• A process is an active instance of a program, with its own memory space, managed by the operating system, such as the JVM process when running a Java application.
• A thread is a lightweight subprocess within a process, sharing the same memory space, enabling concurrent tasks like loading a web page while scrolling, but requiring synchronization to prevent data issues.

Here's a comparison for clarity:

Concept	Definition	Key Characteristics	Examples/Notes
Program	Set of instructions stored in a file, passive until executed.	Executes as a process when dispatched.	E.g., notepad.exe for text editing.
Process	Active instance of a program, with own memory space.	Isolated, heavyweight, involves system calls, does not share memory with others.	JVM process when running Java application; child processes created by parent processes.
Thread	Lightweight subprocess within a process, shares memory.	Shares code, data, resources; has own program counter, register set, stack; faster creation/termination.	Browser tabs as threads; MS Word with formatting and input threads; multitasking via threads.

Threads share memory, which allows efficient communication but risks data inconsistency without proper synchronization.

2. Two Ways of Implementing Threads

Java offers two ways to create threads:

Extending Thread Class

Subclass Thread and override run(). This is straightforward but limits inheritance due to Java's single inheritance rule.

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}
MyThread t = new MyThread();
t.start();
        

Implementing Runnable Interface

Implement Runnable with run(), then pass to Thread. This is preferred for flexibility, allowing class extension elsewhere.

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread running");
    }
}
Thread t = new Thread(new MyRunnable());
t.start();
        

Modern Java also supports lambda expressions for concise thread creation:

Thread t = new Thread(() -> System.out.println("Lambda thread"));
t.start();
        

The Runnable approach is recommended for its design flexibility.

3. Commonly Used Methods in Thread Class

Key methods in the Thread class include:

• start(): Begins thread execution, calling run().
• join(): Waits for the thread to finish, ensuring sequential execution if needed.
• sleep(long millis): Pauses the current thread for the specified time, e.g., Thread.sleep(1000) for 1 second.

Example using join() and sleep():

Thread t = new Thread(() -> {
    try {
        Thread.sleep(1000); // Pause for 1 second
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t.start();
t.join(); // Waits for t to finish
        

Other methods like setPriority() and isAlive() manage thread behavior. Note: wait() and notify() are part of the Object class, used for synchronization, not directly in Thread.

4. Synchronization in Java

Synchronization ensures thread safety when accessing shared resources, preventing race conditions:

Synchronized Methods and Blocks

The synchronized keyword ensures mutual exclusion. Example with a synchronized method:

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}
        

Or with a synchronized block:

class Counter {
    private int count = 0;
    public void increment() {
        synchronized (this) {
            count++;
        }
    }
}
        

wait(), notify() and notifyAll()

These Object class methods enable inter-thread communication:

• wait(): Causes the thread to wait until notified, releasing the lock.
• notify(): Wakes one waiting thread; notifyAll() wakes all.

Example (producer-consumer):

class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 waiting");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 notified");
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 notifying");
                lock.notify();
            }
        });
        t1.start();
        t2.start();
    }
}
        

This ensures threads coordinate effectively, avoiding data corruption.

5. Key Takeaways

• Threads enhance efficiency by enabling concurrent tasks within a process.
• Choose Runnable over extending Thread for flexibility.
• Use start(), join(), sleep() for thread management, and synchronized with wait()/notify() for safe shared resource access.
• Proper synchronization is vital to avoid data corruption in multi-threaded environments.

6. Conclusion

Mastering Java threads and synchronization is key for developing robust, concurrent applications. By understanding these concepts, developers can create efficient, responsive software that leverages multi-threading effectively.

References

• Difference between Process and Thread - GeeksforGeeks
• Java Threads - W3Schools
• Guide to the Synchronized Keyword in Java - Baeldung
• Synchronization in Java - GeeksforGeeks
• Threads vs. Processes: How They Work Within Your Program - Backblaze
• Difference Between Process and Thread - Guru99
• Oracle Java Tutorials