Computer Science Roadmap

Learn computing fundamentals, programming, algorithms, systems, and software engineering.

Overall Progress0%

Operating Systems

Explanation

An operating system is the software that manages a computer’s hardware and gives applications a clean, safe place to run. Without it, every program would have to talk to the disk, memory, and devices directly, and one buggy program could crash the whole machine. The OS juggles four big responsibilities: managing processes, managing memory, managing files, and managing devices. It also enforces security so programs cannot stomp on each other. This lesson explains what a process and a thread are, why concurrent programs produce race conditions, how locks and semaphores fix them, what deadlock is, and how virtual memory and paging let many programs share one machine safely.

What Does an Operating System Do?

Process management

Memory management

File systems

Device management

Security and protection

The OS sits between applications and hardware, providing services through system calls.

Program vs Process

A program is a file of instructions on disk. A process is a running instance of that program in memory. One program can run as many processes.

Process Lifecycle

New

↓

Ready

↓

Running

↓

Terminated

A process is created, waits until the scheduler gives it the CPU, runs, and eventually terminates. Waiting states are inserted when it blocks on I/O.

Processes vs Threads

	Process	Thread
Memory	Has its own address space	Shares the process’s address space
Cost	Heavier to create	Lighter to create
Communication	Inter-process (harder)	Shared memory (easier)
Analogy	An application	A worker inside an application

Concurrency and Race Conditions

When multiple threads update shared data without coordination, the interleaving of their operations can produce wrong results. This is a race condition.

python

1counter = 02 3def increment():4    global counter5    for _ in range(100000):6        counter += 1   # read-modify-write: not atomic

Locks and Mutexes

A mutex (mutual exclusion lock) lets only one thread enter a critical section at a time. The other threads wait until the lock is released.

python

1lock = threading.Lock()2 3def increment():4    global counter5    for _ in range(100000):6        with lock:7            counter += 1

Semaphores

	Mutex	Semaphore
Count	Binary (locked/unlocked)	Can count up to N
Use	Mutual exclusion	Limit N threads into a section / signal events
Who unlocks	Only the owner	Any thread

Deadlock

Deadlock happens when threads wait on each other in a cycle and none can proceed. Four conditions must all hold: mutual exclusion, hold-and-wait, no preemption, and circular wait.

text

1Thread A holds lock 1, wants lock 22Thread B holds lock 2, wants lock 13 4Neither can proceed — deadlock.

Memory Management and Paging

The OS gives each process a private virtual address space, then maps it to physical memory in fixed-size blocks called pages. The page table records which virtual page maps to which physical frame.

Virtual address

↓

Page table lookup

↓

Physical frame

↓

Data in RAM

File Systems and System Calls

The file system organises files and directories on disk and stores metadata such as names, sizes, and permissions. Applications ask the OS to work on files through system calls such as open, read, write, and close. System calls run in kernel mode, which has full hardware access, while ordinary application code runs in user mode.

Syntax

Threads and a mutex in Pythonpython

1import threading2 3counter = 04lock = threading.Lock()5 6def increment():7    global counter8    for _ in range(100000):9        with lock:10            counter += 111 12threads = [threading.Thread(target=increment) for _ in range(4)]13for t in threads: t.start()14for t in threads: t.join()15print(counter)  # 400000

Without the lock, counter may be less than 400000 because of the race condition.

Examples

Race condition vs mutex

Run the counter with and without a lock to see the difference.

python

1import threading2 3counter = 04lock = threading.Lock()5 6def inc_locked():7    global counter8    for _ in range(100000):9        with lock:10            counter += 111 12threads = [threading.Thread(target=inc_locked) for _ in range(4)]13for t in threads: t.start()14for t in threads: t.join()15print(counter)

Output

Key Takeaways

The OS manages processes, memory, files, devices, and security.
A process is an isolated running program; threads share a process’s memory.
Race conditions come from unsynchronized access to shared data.
Mutexes give mutual exclusion; semaphores count permits.
Deadlock needs four conditions: mutual exclusion, hold-and-wait, no preemption, circular wait.
Paging maps virtual memory to physical memory through page tables.

← PreviousComputer Architecture Next →Databases