Process in OS: Definition, Program vs Process & Structure

A Process Control Block (PCB) is a data structure maintained by the operating system for every process, storing all information from creation to termination. The PCB resides in kernel memory space and contains fields including Process ID (unique identifier), Process State (New, Ready, Running, Blocked, Waiting, Terminated), Parent Process Pointer, Priority, Program Counter, CPU Registers, I/O Status Information, Device Allocation, Accounting Information, and CPU Time Limit. Context Switching is the process of stopping one process and restarting another, occurring when CPU time expires or a higher priority process arrives. The sequence involves OS intervention via interrupt, saving current process state to its PCB, restoring new process state from its PCB, and transferring control. This is pure overhead as no useful work occurs during switching. Context switching enables multitasking by efficiently managing CPU allocation among multiple processes.

The Process Control Block (PCB) is a data structure storing all process information: PID, group ID, program counter, general register set, priority, state, size, type, list of open files, list of open devices, and accounting information. The PCB content is called process context, representing the complete process state. The PCB is also called a process descriptor and is part of the OS kernel data structure, never accessed by user programs. Context switching involves saving the current process's PCB and loading another process's PCB to switch CPU execution, enabling multitasking and efficient CPU utilization.

The Process Control Block (PCB) is a data structure that stores all information about a process for management. It contains: Process ID (unique identifier), Program Counter (address of next instruction), CPU Registers, Device Permissions, Process State (running, ready, waiting), Priority, Memory Limits, and List of Open Files. The Context of a process is the complete collection of values stored in its PCB. Context Switch is the process of saving the current running process's context to its PCB and loading another process's context from its PCB into the CPU registers. This enables multitasking by allowing the CPU to switch between processes efficiently.

The Process Control Block (PCB) stores all information about a process, including Process State, Program Counter, CPU Registers, Memory Limits, List of Open Files, CPU Scheduling Information, Accounting Information, and I/O Status Information. Context switching is the mechanism by which the operating system saves the current process's state to its PCB and loads the state of another process from its PCB. This involves saving CPU registers, memory limits, open files, and other process information. The switch must be very fast since the CPU cannot perform useful work during the switch. Hardware support is often used to minimize context switch overhead. The PCB enables the operating system to suspend and resume processes efficiently, maintaining the illusion of concurrent execution.

The Process Control Block (PCB) is the OS's data structure storing all process information including state, registers, memory allocation, and open files. Context switching involves saving the current process's PCB and loading another's, enabling seamless process switching. This mechanism preserves execution progress across interruptions, allowing the OS to manage multiple processes efficiently despite the CPU executing only one at a time.

CPU scheduling algorithms determine which process gets CPU time. Key algorithms include: (1) FCFS (First-Come-First-Served) - non-preemptive, FIFO order, (2) SJF (Shortest Job First) - non-preemptive, minimizes average waiting time, (3) SRTF (Shortest Remaining Time First) - preemptive version of SJF, (4) Round Robin - preemptive, provides fair CPU allocation, (5) Priority Scheduling - processes with higher priority run first. Key metrics for evaluation: (1) Turnaround Time - total time from arrival to completion, (2) Waiting Time - time spent in ready queue, (3) Response Time - time from arrival to first CPU allocation.

CPU scheduling algorithms include FCFS (First Come First Serve), SJF (Shortest Job First), SRTF (Shortest Remaining Time First), Priority Scheduling, Round Robin, and Multilevel Queueing. Mastering these algorithms enables solving any CPU scheduling problem in GATE exams.

CPU scheduling algorithms determine the order in which processes are executed on the CPU, with five main algorithms: First-Come-First-Served (FCFS) executes processes in arrival order; Shortest Job First (SJF) selects the process with the shortest burst time; Preemptive Shortest Job First (SRTF) preempts the current process if a shorter one arrives; and Round Robin (RR) allocates fixed time quantum slices to processes in a circular manner. Each algorithm calculates key metrics including waiting time (time spent in ready queue), turnaround time (total time from arrival to completion), and average turnaround time (sum of all turnaround times divided by number of processes).

CPU scheduling determines which process should get the CPU, which process should wait, and after how long a process should be given the CPU. There are many different rules (algorithms) for CPU scheduling, and the choice depends on the specific situation and requirements of the system.

Key scheduling algorithms: (1) FCFS (First-Come-First-Served) - executes processes in arrival order; (2) SJN (Shortest-Job-Next) - executes shortest CPU time first (non-preemptive); (3) Round-Robin - each process gets a time quantum, returns to ready queue when quantum expires or blocks (preemptive with feedback); (4) Priority Scheduling - highest priority process selected first (can cause starvation, solved by aging); (5) SRTF (Shortest-Remaining-Time-First) - gives priority to process with least remaining time (preemptive); (6) HRRN (Highest Response Ratio Next) - gives priority to process with highest response ratio. The lesson concludes by summarizing the covered topics: monoprogramming vs multiprogramming, swapping, process states, performance metrics, processing types, and scheduling algorithms.

A thread is a lightweight process that shares the address space of its parent process, allowing multiple threads within a single process to execute concurrently while sharing resources like code, data, and heap sections. Unlike processes, which require separate address spaces and have higher overhead, threads have their own program counter, stack, and registers but share common resources, making them more efficient for concurrent execution. Multithreading is beneficial for server-side applications (handling multiple client requests concurrently), client-side applications (like web browsers downloading multiple resources simultaneously), and standalone applications (like Microsoft Word performing spell-checking while editing). The key advantages include resource sharing, lower context-switching overhead, and the ability to exploit multicore architectures for parallel execution.

This comprehensive introduction covers the fundamental concepts of threads and multithreading in operating systems. A process is an executing program (like a web browser or music player) that can be visualized as a workshop with its own memory space and tools. A thread is a worker within a process's workshop, and a process can contain multiple threads. Processes are heavyweight with their own memory space, while threads are lightweight because they share the same memory space. This sharing makes thread creation and switching much faster. The kitchen analogy illustrates how multiple tasks (chopping vegetables, cooking rice, answering phone calls) can happen simultaneously within the same kitchen (process) using shared resources. Context switching between threads is faster than between processes because threads share memory, eliminating the need to move memory and tools.

Threads enable concurrent execution of multiple tasks. Syntax: Thread t = new Thread(() -> System.out.println("Thread"));. The Runnable interface defines the run() method. Thread.sleep() pauses execution for a specified time. Multiple threads can run concurrently, improving performance for CPU-bound tasks. Thread management is essential for responsive applications.

A Java thread is a lightweight sub-process representing the smallest independent unit of a program with its own path of execution; every Java application has at least one main thread, and threads follow a lifecycle including new, runnable, running, waiting/blocked, and terminated states. Threads can be created either by extending the Thread class or implementing the Runnable interface, with the latter being preferred when multiple inheritance is needed. Multi-threading enables concurrent execution of multiple tasks within a single application, improving responsiveness and resource utilization, but requires synchronization mechanisms like synchronized methods or blocks when multiple threads access shared resources to prevent race conditions and ensure data consistency.

A thread is a lightweight process that enables concurrent execution of multiple tasks within a single application, allowing different operations (such as importing, exporting, previewing, and opening settings) to run simultaneously rather than sequentially; this parallel processing significantly reduces overall execution time compared to single-threaded execution where tasks must complete one after another, similar to how multiple cashiers at a McDonald's can serve customers faster than a single cashier.

Inter-process communication (IPC) is a mechanism that enables processes within a computer system to communicate with each other and synchronize their actions, serving purposes such as information sharing, resource sharing, computational speed-up, synchronization, modularity, and convenience. IPC operates through two primary mechanisms: shared memory, where processes access a common memory region to exchange data with the help of the operating system managing resource records, and message passing, where processes communicate using send and receive primitives without shared memory, establishing communication links and exchanging discrete messages with process IDs and content.

Inter Process Communication (IPC) is a mechanism that allows one process to communicate with another process. In multi-programming systems where multiple processes reside in main memory, IPC enables processes to exchange information and coordinate their activities.

Inter-Process Communication (IPC) is a set of programming interfaces that enable data exchange between multiple threads in one or more processes running concurrently in Linux or Unix operating systems. IPC methods include direct communication (processes name each other explicitly with one link per pair), indirect communication (processes share common mailboxes with multiple links), message passing (send/receive operations without shared variables), shared memory (memory area shared between processes requiring synchronization), FIFO (full-duplex communication between unrelated processes), message queues (kernel-linked lists with full-duplex capacity), and pipes (half-duplex communication between related processes requiring two pipes for bidirectional flow). IPC is essential for speeding up computation, achieving modularity, enabling privilege separation, providing programming convenience, and synchronizing processes.

Inter-Process Communication (IPC) is the mechanism by which processes exchange information and coordinate their actions. For processes to communicate, they must share a common medium (shared memory, pipes, message queues, etc.). IPC enables processes to pass data, synchronize their activities, and coordinate resource access. Without IPC, processes cannot effectively interact or share information, making it impossible to implement complex multi-process applications.

Interprocess communication (IPC) is the mechanism by which processes communicate with each other to cooperate. Since processes have separate virtual address spaces and cannot readily read or write each other's variables, IPC provides facilities for communication. The term 'inter' is sometimes omitted because there is little concept of communication inside a process anyway. IPC is essential for concurrent programming because processes must somehow communicate in order to cooperate, similar to how humans cooperate through various forms of communication like talking, passing notes, or sending emails.