What are interrupts? They are signals that tell a processor to pause normal execution and respond to an urgent event. Interrupts support multitasking, user input, timers, and hardware communication. In this article, I explain what are interrupts, how they work, and why they keep modern computer systems fast, responsive, and reliable.
What Are Interrupts?
An interrupt is a signal that tells the processor that an event needs attention.
Normally, the CPU executes instructions in sequence. However, some events occur independently. A keyboard receives input. A timer expires. A network adapter receives data.
Therefore, the system needs a way to notify the processor.
An interrupt temporarily redirects the CPU to a specific Interrupt Service Routine, or ISR, that handles the event.
Afterward, the processor returns to the interrupted program.
Why Interrupts Matter
Without interrupts, the CPU could repeatedly check whether each device needs attention. This technique is called polling.
Polling can be useful. However, continuous polling often wastes processor time.
With interrupts, the processor can perform other work until a device signals that something has happened.
Polling asks for changes repeatedly, while interrupts report changes when they occur.
This makes interrupt-driven systems more efficient.
How an Interrupt Works
The exact details depend on the processor architecture. However, the basic process is similar.
First, a device or another interrupt source sends a request.
Next, the processor determines whether it can accept the interrupt. If it does, it saves enough information to continue the current program later. This usually includes the current instruction position and processor status.
Then, the CPU identifies the correct ISR and transfers control to it.
The ISR handles the event. For example, it may read input, acknowledge a device, or process completed data.
Finally, the processor restores the previous state and continues the interrupted program.
The CPU can therefore respond to an event without permanently disturbing the program that was running.
Interrupt Vectors and Priorities
A computer usually has many interrupt sources. Therefore, the CPU must know which handler belongs to each source.
Most systems use interrupt vectors or similar identifiers. Each interrupt points to the appropriate handler.
The system must also resolve competing requests. For this reason, interrupts can have different priorities.
A high-priority interrupt may receive attention before a lower-priority one. In some systems, it can even interrupt another ISR.
Interrupt controllers help manage this process. They collect interrupt requests, assign priorities, and forward them to the processor.
Maskable and Non-Maskable Interrupts
Many processors distinguish between maskable and non-maskable interrupts.
A maskable interrupt can be temporarily disabled or delayed. This can protect critical operations.
A non-maskable interrupt, or NMI, normally represents a more serious event that ordinary interrupt masking should not suppress.
Non-maskable does not mean impossible to delay under every condition. It means that normal interrupt masks cannot disable it.
Interrupts and Input/Output
Interrupts are especially important for I/O.
For example, the processor can start a storage operation and then continue other work. When the storage device finishes, it sends an interrupt.
Therefore, the CPU does not have to wait for the device.
This principle becomes even more efficient when combined with Direct Memory Access, or DMA. DMA can move blocks of data without requiring the processor to copy each byte.
When the transfer finishes, the device can generate an interrupt.
DMA moves data efficiently, while interrupts tell the processor when attention is needed again.
Timer Interrupts and Multitasking
Operating systems also use timer interrupts.
A hardware timer periodically returns control to the operating system. The scheduler can then decide whether the current process should continue or another process should run.
Therefore, timer interrupts support preemptive multitasking.
However, the timer itself does not switch tasks.
The interrupt gives the operating system an opportunity to schedule another task; the scheduler makes the actual decision.
Interrupts, Exceptions, and System Calls
These concepts are related, but they are not identical.
A hardware interrupt usually comes from an external source, such as a timer or device.
An exception results from the currently executing instruction. Examples include division by zero, invalid instructions, and page faults.
A system call occurs when a program deliberately requests a service from the operating system.
Older systems sometimes implemented system calls through software interrupts. Modern processors often use dedicated system-call instructions instead.
Interrupts, exceptions, and system calls can use similar control mechanisms, but they represent different types of events.
Interrupt Latency
Interrupt latency is the delay between an interrupt request and the processor beginning to handle it.
Low latency matters in embedded and real-time systems. However, predictability matters just as much.
A real-time system may need to guarantee that an important interrupt receives attention within a defined maximum time.
For this reason, interrupt handlers should usually remain short. They handle urgent work first and postpone less critical processing when possible.
Final Thoughts
Interrupts are a fundamental mechanism in modern computer systems.
They allow devices to notify the CPU efficiently. They support responsive I/O, multitasking, timers, DMA, and reliable event handling.
Most importantly, they prevent the processor from wasting time constantly checking whether something has happened.
An interrupt lets the CPU continue useful work until an event actually requires its attention.
What’s Next?!
Now that I understand interrupts, I can explore where data and instructions live while programs run. Interrupts change normal execution flow. However, the system still needs memory to store values, addresses, instructions, and temporary information. Therefore, the next article, “Computer Memory: A Clear and Simple Guide,” is the perfect next step. Read it next to see how memory supports program execution, system performance, and reliable computing.
Discover the Foundations Behind Modern Technology
Technology becomes easier to understand when I connect each concept to real computer behavior. In my main article on Technology, I explore operands, switching systems, the ALU, the control unit, the program counter, Von Neumann architecture, RISC vs. CISC, machine instructions, assembly language, memory, input and output interfaces, offsets, buses, processor registers, stack pointers, and encryption algorithms.
Therefore, this guide helps me see how computers process data, execute instructions, manage memory, move information, and protect digital systems. As a result, I strengthen my understanding of computer architecture, processor behavior, data flow, low-level programming, system communication, and digital security.
Credits: Photo by cottonbro studio from Pexels