Threads in Java

🚀 Introduction to Threads in Java

In Java, a thread is a lightweight subprocess, the smallest unit of processing. Threads in Java are used to achieve multitasking, enabling a program to perform two or more operations simultaneously.

With threads, you can build applications that are more responsive and efficient, especially in environments where performance and concurrency are critical.

🧠 What Are Threads in Java?

Threads in Java represent independent paths of execution. They allow parts of your program to run concurrently rather than sequentially.

For example, in a game, one thread might handle graphics rendering while another handles user input, both running in parallel.

🔧 Ways to Create Threads in Java

• By Extending the Thread Class
• By Implementing the Runnable Interface

// Method 1: Extending Thread
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running via Thread class...");
    }
}
MyThread t1 = new MyThread();
t1.start();

// Method 2: Implementing Runnable
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running via Runnable interface...");
    }
}
Thread t2 = new Thread(new MyRunnable());
t2.start();

📊 Thread Lifecycle

A thread in Java goes through several states during its lifecycle:

1. New: Thread is created but not yet started.
2. Runnable: Thread is ready to run.
3. Running: Thread is executing its task.
4. Blocked/Waiting: Thread is inactive temporarily.
5. Terminated: Thread has completed execution.

⚙️ Commonly Used Thread Methods

• start() – Starts a new thread.
• run() – Defines the task that a thread will execute.
• sleep(ms) – Pauses the thread for specified milliseconds.
• join() – Waits for a thread to die.
• isAlive() – Checks if a thread is alive.

Thread t = new Thread(() -> {
    try {
        Thread.sleep(1000);
        System.out.println("Thread woke up!");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t.start();

🔒 Synchronization in Threads

When multiple threads access shared resources, data inconsistency can occur. To avoid this, Java provides synchronization.

It ensures that only one thread can access the resource at a time.

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

📥 Thread Priorities

Each thread has a priority, which helps the thread scheduler determine the order of execution.

Priority can be set using:

thread.setPriority(Thread.MAX_PRIORITY);   // 10
thread.setPriority(Thread.MIN_PRIORITY);   // 1
thread.setPriority(Thread.NORM_PRIORITY);  // 5 (default)

🧵 Daemon Threads

Daemon threads are background service threads. They're useful for tasks like garbage collection.

They terminate when all user threads finish execution.

Thread daemon = new Thread(() -> {
    while (true) {
        System.out.println("Daemon thread running...");
    }
});
daemon.setDaemon(true);
daemon.start();

🎯 Advantages of Using Threads

• Improved performance for multi-core systems.
• Better resource utilization through concurrent tasks.
• Enhanced responsiveness in GUI and server applications.
• Efficient background processing using daemon threads.

✅ Conclusion

Understanding Threads in Java is key to writing efficient, high-performing Java applications.

Whether you are building multi-threaded desktop software, high-concurrency server systems, or responsive UIs, Java’s threading model offers the power and flexibility needed to manage complex execution flows with ease.