Embedded Prep

Multithreading in Operating System: When you use a computer or smartphone, you often run many tasks simultaneously — like playing music while browsing the web or downloading files while writing a document. Multithreading is one key concept that allows this seamless multitasking to happen smoothly and efficiently.

In simple terms, multithreading is the technique where a single process is divided into multiple threads, each capable of running independently but sharing the same memory and resources. Threads are like tiny workers inside a program, each handling a different part of the task. This makes programs faster, more responsive, and better at utilizing modern multi-core processors.

Multithreading in operating systems plays a crucial role in managing how these threads are created, scheduled, and executed. The operating system acts like a manager, deciding which thread runs when, on which processor core, and for how long. It ensures that threads don’t interfere with each other in harmful ways, especially when accessing shared data.

Using multithreading, applications can perform multiple operations at once. For example, a web browser might:

• Load images and videos in one thread
• Render the web page in another thread
• Handle user clicks and typing in yet another thread
• Download files in the background without freezing the interface

This makes applications smoother and keeps devices responsive, even when running complex or multiple tasks.

However, multithreading isn’t without challenges. When threads share memory and resources, they can run into issues like:

• Race conditions — when two threads try to modify the same data simultaneously
• Deadlocks — when threads are stuck waiting for each other’s resources
• Starvation — when a thread never gets CPU time because others keep running

To prevent such problems, operating systems provide synchronization tools like mutexes, semaphores, and locks, helping developers control how threads access shared resources safely.

In this article, we will explore:

✅ What is multithreading in operating systems?
✅ Benefits of using multithreading
✅ How threads work and how the OS manages them
✅ Common problems in multithreaded applications
✅ Beginner-friendly coding examples to see multithreading in action

Whether you’re a student, beginner programmer, or tech enthusiast, understanding multithreading in operating system is essential for creating efficient, high-performing applications. Dive in and discover how your computer does many things at once — all thanks to multithreading!

What is Multithreading?

Multithreading means running multiple threads — independent sequences of instructions — inside a single program or process at the same time (or seemingly so).

• A process is a program in execution, like your browser.
• A thread is a smaller unit of work within that process.

Think of a process as a factory, and threads as workers in that factory, each handling a different task.

Why Use Multithreading?

1. Better CPU Usage

Most modern CPUs have multiple cores that can work simultaneously. Multithreading lets a program run multiple parts in parallel to use the CPU efficiently.

2. Improved Responsiveness

Apps with multiple threads remain responsive. For example, your music player can play songs on one thread while another thread handles your commands.

3. Simpler Code Structure for Concurrent Tasks

Breaking big tasks into threads can make the program easier to design and maintain.

Basic C++ Code Example: Creating and Running Threads

Let’s see how to create and run threads in C++ using the standard library.

#include <iostream>
#include <thread>  // For std::thread

// Function to be run by a thread
void printNumbers() {
    for (int i = 1; i <= 5; i++) {
        std::cout << "Thread: " << i << std::endl;
    }
}

int main() {
    std::thread t1(printNumbers);  // Create a thread that runs printNumbers()

    // Meanwhile, main thread runs this loop
    for (int i = 1; i <= 5; i++) {
        std::cout << "Main thread: " << i << std::endl;
    }

    t1.join();  // Wait for thread t1 to finish

    return 0;
}

What happens here?

• We create a new thread t1 that runs the function printNumbers.
• The main thread runs its own loop printing messages.
• Both run concurrently, so the output lines from the two threads interleave.
• t1.join() makes the main thread wait for t1 to complete before exiting.

How Does Multithreading Work in an OS?

The OS manages threads through a process called scheduling — deciding which thread runs on which CPU core and when.

Threads go through these states:

• New: Thread is created.
• Runnable: Ready to run.
• Running: Actively executing.
• Blocked/Waiting: Paused, waiting for resources or events.
• Terminated: Finished execution.

The OS rapidly switches between threads to give the illusion they run simultaneously, especially when CPU cores are fewer than threads.

Thread vs Process

• Process: Has its own memory space.
• Thread: Shares memory with other threads in the same process.

This sharing allows faster communication but can cause problems if not carefully handled.

Synchronization: Avoiding Race Conditions

When multiple threads share data, they can conflict. For example:

#include <iostream>
#include <thread>
#include <mutex>

int counter = 0;
std::mutex mtx;  // Mutex to protect counter

void increaseCounter() {
    for (int i = 0; i < 10000; i++) {
        mtx.lock();    // Lock before accessing shared data
        counter++;     // Critical section
        mtx.unlock();  // Unlock after done
    }
}

int main() {
    std::thread t1(increaseCounter);
    std::thread t2(increaseCounter);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

Explanation

• Two threads increase the same counter.
• Without the mutex (mtx), the final value might be incorrect due to race conditions.
• The mutex ensures only one thread changes counter at a time, preventing errors.

Common Multithreading Problems

1. Race Conditions

When threads change shared data at the same time without synchronization.

2. Deadlocks

When two or more threads wait for each other’s resources and none can proceed.

3. Starvation

When some threads never get CPU time because others monopolize it.

Real-Life Example: Web Browser

A browser uses multiple threads:

• One to load images.
• One to render pages.
• One to handle user input.
• One to download files.

Even if one thread is slow (e.g., waiting for network), others keep running so the app feels responsive.

Summary

Multithreading helps programs run tasks simultaneously, improving speed and responsiveness. However, it requires careful synchronization to avoid problems like race conditions and deadlocks.

Learning multithreading is essential to modern software development, and starting with simple examples like these will help build your foundation.