X86 Assembly/X86 Interrupts
Interrupts are special routines that are defined on a per-system basis. This means that the interrupts on one system might be different from the interrupts on another system. Therefore, it is usually a bad idea to rely heavily on interrupts when you are writing code that needs to be portable.
What is an Interrupt? 
Interrupts do exactly what the name suggests: they interrupt the control flow of the x86 processor. When an interrupt is triggered by an event (internal or external), the processor does a few things before the interrupt is serviced. It finishes executing the current instruction and then saves its context, usually on the stack. The processor then jumps to a special program called an "Interrupt Service Routine" (ISR). Each ISR is a function in memory that handles a particular interrupt. When the ISR is finished, the microprocessor normally jumps right back to where it was in the original program (however, there are interrupts that don't do this). In the case of hardware interrupts, the program doesn't even have to know that it got interrupted: the change is seamless.
In modern operating systems, the programmer often doesn't need to use interrupts. In Windows, for example, the programmer conducts business with the Win32 API. However, these API calls interface with the kernel, and the kernel will often trigger interrupts to perform different tasks. However, in older operating systems (specifically DOS), the programmer didn't have an API to use, and so they had to do all their work through interrupts.
Interrupt Instruction 
This instruction issues the specified interrupt. For instance:
Calls interrupt 10 (0x0A (hex) = 10 (decimal)).
Types of Interrupts 
There are 3 types of interrupts: Hardware Interrupts, Software Interrupts and Exceptions.
Hardware Interrupts 
Hardware interrupts are triggered by hardware devices. For instance, when you type on your keyboard, the keyboard triggers a hardware interrupt. The processor stops what it is doing, and executes the code that handles keyboard input (typically reading the key you pressed into a buffer in memory). Hardware interrupts are typically asynchronous - their occurrence is unrelated to the instructions being executed at the time they are raised.
Software Interrupts 
There are also a series of software interrupts that are usually used to transfer control to a function in the operating system kernel. Software interrupts are triggered by the instruction int. For example, the instruction "int 14h" triggers interrupt 0x14. The processor then stops the current program, and jumps to the code to handle interrupt 14. When interrupt handling is complete, the processor returns flow to the original program.
Exceptions are caused by exceptional conditions in the code which is executing, for example an attempt to divide by zero or access a protected memory area. The processor will detect this problem, and transfer control to a handler to service the exception. This handler may re-execute the offending code after changing some value (for example, the zero dividend), or if this cannot be done, the program causing the exception may be terminated.
Further Reading 
A great list of interrupts for DOS and related systems is at Ralph Brown's Interrupt List.