Problem stems from fact that some devices may only be used for one thing at a time. The classic example is the printer. Whereas a screen may be used by many processes at a time, by dividing it into overlapping windows, or a disk may be used by many processes at a time, by dividing it up into files, the printed page may not be divided up in this way.
One approach might be to allow processes to claim exclusive use of the printer, but that holds up other processes wishing to print, means that a printing process must work at the physical speed of the printer, and a process might be held up by other things while it is printing (say it is swapped out), which makes its use of the printer time inefficient.
The answer is to let processes produce their print job off-line, and have it submitted to the physical printer some time later, when it is finished. Instead of printing to the physical printer, processes may print to the print spooler. This behaves just like the real printer (accepts the same set of instructions), but writes to a file instead of to a device, and therefore is much faster than a physical printer, and may be shared among many different tasks.
The spooler prints jobs at its discression, usually in the order in which the jobs are completed. A daemon process (the print daemon) is responsible for accepting spooled print jobs, and later sending them to the physical printer. In a system which uses spooling, needless to say, only the print daemon is actually allowed to write to the physical printer (only it has permission).
Though most common in printing, spooling can be used in many circumstances where output may be produced off-line, and the device to be used may not be shared.
For example, sending of e-mail messages is 'spooled', in that messages are composed completely, and sent by some mail daemon at a convenient later date. In cases where the file to be generated is very large (for example, writing 3GB of data to a backup tape), spooling is impractical, and the device must be grabbed exclusively.