Multitasking vs Multithreading in Java

Multitasking and multithreading both describe doing more than one thing "at once," but they operate at different levels of the operating system, and Java's Thread API specifically targets the second one. Understanding the distinction clarifies why threads are described as "lightweight" compared to processes.

Why it matters

Threads are useful because they share memory, and dangerous for the same reason. This lesson's distinction — separate processes with separate memory versus threads inside one process sharing a heap — explains both why multithreading is fast and why two threads can corrupt each other's data.

Process-Based Multitasking

Process-based multitasking means the operating system runs multiple independent programs (processes) at the same time — for example, a web browser and an IDE running simultaneously on your machine. Each process has its own separate memory space, its own set of system resources, and its own address space that other processes cannot directly access. Communication between processes (inter-process communication) requires explicit mechanisms like sockets, pipes, or files, because processes do not share memory by default. Starting a new process and switching the CPU between processes is relatively expensive for the operating system.

Thread-Based Multitasking (Multithreading)

Thread-based multitasking, or multithreading, means multiple threads run concurrently within a single process. All threads in that process share the same memory space — the same heap, the same static fields, the same open file handles — while each thread still keeps its own call stack and program counter. This shared memory makes communication between threads trivial (they can simply read and write the same objects), but it is also exactly why multithreaded code needs careful synchronization: two threads can otherwise interfere with each other while accessing the same data at the same time.

Why Threads Are Lighter Than Processes

Creating a new process requires the operating system to allocate an entirely new memory space and duplicate a range of OS-level resources, which is comparatively slow and resource-intensive. Creating a new thread within an existing process only requires a new stack and some thread-local bookkeeping, because it reuses the process's existing memory space and resources. This is why thread creation and context switching between threads is considerably cheaper than process creation and context switching, and why a single Java application can comfortably run many threads (for example, one per client connection in a server) but would struggle to spawn a comparable number of separate processes.

Example

public class MultithreadingDemo {
    static int sharedCounter = 0; // shared memory: visible to every thread in this process

    public static void main(String[] args) throws InterruptedException {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 1000; i++) {
                synchronized (MultithreadingDemo.class) {
                    sharedCounter++;
                }
            }
        };

        Thread t1 = new Thread(incrementTask, "T1");
        Thread t2 = new Thread(incrementTask, "T2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Both threads incremented the SAME shared variable -- this is only
        // possible because threads of one process share memory.
        System.out.println("Final counter value: " + sharedCounter);
    }
}

Final counter value: 2000

Exercise

Split a sum across two threads. One thread adds the numbers 1 to 100 and the other adds 101 to 200. Each stores its result in its own slot of a shared array, so they never write to the same place. After both finish, print the total.

Expected output: 20100

public class SplitSum {

    static int sumRange(int from, int to) {
        int sum = 0;
        for (int i = from; i <= to; i++) {
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws InterruptedException {
        int[] results = new int[2];

        // TODO: thread one stores sumRange(1, 100) in results[0]
        // TODO: thread two stores sumRange(101, 200) in results[1]
        // TODO: start both, wait for both, then print results[0] + results[1]
    }
}

public class SplitSum {

    static int sumRange(int from, int to) {
        int sum = 0;
        for (int i = from; i <= to; i++) {
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws InterruptedException {
        int[] results = new int[2];

        Thread first = new Thread(() -> results[0] = sumRange(1, 100));
        Thread second = new Thread(() -> results[1] = sumRange(101, 200));

        first.start();
        second.start();
        first.join();
        second.join();

        System.out.println(results[0] + results[1]); // 20100
    }
}

Quick quiz

Interview questions