Multithreaded programming

Comparison of single-threaded vs multithreaded execution flows"

Multithreaded programming is a programming paradigm that enables concurrent execution of tasks within a single process, dramatically improving performance for modern applications. It allows multiple threads to run simultaneously, sharing the same memory space while executing different parts of a program. This is particularly beneficial for CPU-bound tasks, where processing power can be maximized by distributing workloads across multiple threads. In this guide, we’ll explore how multithreading works, its real-world applications in areas such as web servers, video games, and scientific computations, and critical considerations for developers, including thread synchronization, deadlock avoidance, and the complexity of managing shared resources to ensure thread safety.

Table of Contents

What is Multithreaded Programming?

Multithreading allows a CPU to manage multiple execution threads simultaneously. Key concepts:

Thread: Smallest sequence of programmed instructions
Concurrency: Illusion of parallel execution
Parallelism: Actual simultaneous execution (requires multi-core CPU)

// Java Thread Example
public class MyThread extends Thread {
  public void run() {
    System.out.println("Thread is running");
  }

  public static void main(String args[]) {
    MyThread t1 = new MyThread();
    t1.start(); // Starts new thread
  }
}

Why Use Multithreading?

Use Case	Benefit	Example
I/O Operations	Non-blocking execution	File processing
CPU-Intensive Tasks	Core utilization	Video encoding
Responsive UIs	Prevent freezing	Desktop/mobile apps
Web Servers	Concurrent requests	Apache/Nginx

Multithreading vs. Multiprocessing

Factor	Multithreading	Multiprocessing
Memory	Shared memory	Isolated memory
Creation Cost	Low	High
Communication	Direct	IPC required
Fault Isolation	Weak	Strong

Common Multithreading Challenges

1. Race Conditions

# Python Example (Shared Counter)
import threading

counter = 0

def increment():
    global counter
    for _ in range(100000):
        counter += 1

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)

t1.start()
t2.start()
t1.join()
t2.join()

print(counter) # May not be 200000!

Solution: Use locks/mutexes

lock = threading.Lock()

def safe_increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

2. Deadlocks

Four necessary conditions:

Mutual Exclusion
Hold and Wait
No Preemption
Circular Wait

Multithreading in Different Languages

1. Java

// Using ExecutorService (Thread Pool)
ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> System.out.println("Task running"));
executor.shutdown();

2. C#

// Task Parallel Library
Parallel.For(0, 10, i => {
    Console.WriteLine($"Task {i}");
});

3. JavaScript/Node.js

// Worker Threads (Node.js)
const { Worker } = require('worker_threads');

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.postMessage('Hello from worker!');
`);

worker.on('message', (msg) => console.log(msg));

Best Practices

Use Thread Pools
Avoid unlimited thread creation

   Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

Immutable Data
Prefer thread-local or read-only data
Atomic Operations
Use atomic variables when possible

   AtomicInteger counter = new AtomicInteger(0);
   counter.incrementAndGet();

Avoid Premature Optimization
Measure performance before threading