Multiprocessing is a computing approach where two or more processors (CPUs or cores) work simultaneously to execute tasks. Instead of a single processor handling every instruction one at a time, multiprocessing splits the workload across multiple processors so that several operations happen at once. This is the foundation of virtually every modern computer, phone, and server.
How Multiprocessing Works
At its simplest, a multiprocessor system contains at least two processing units that can each execute their own stream of instructions independently. When you open a web browser, play music, and run a file download at the same time, your operating system can assign each of those tasks to a different processor core so they genuinely run in parallel, not just take rapid turns on a single core.
The processors coordinate through shared resources. In a typical multi-core chip, each core has its own small, fast memory caches (called L1 and L2), while a larger but slower cache (L3) is shared among all cores. All cores also share access to main memory, storage devices, and network connections. Data written by one core becomes available to the others through this shared memory. The operating system manages the whole arrangement, dynamically scheduling tasks across available cores so no single core sits idle while others are overloaded.
Symmetric vs. Asymmetric Multiprocessing
There are two broad ways to organize multiple processors, and they have very different philosophies.
Symmetric multiprocessing (SMP) treats every processor as an equal peer. All cores share the same memory, run the same operating system, and can execute any task. There’s no hierarchy. The OS dynamically assigns work to whichever core is available, and each core accesses any memory location with roughly the same speed. This is what you’ll find in most desktop computers, laptops, and servers today.
Asymmetric multiprocessing (AMP) assigns distinct roles to different processors. One “master” CPU controls the system and delegates specific jobs to secondary processors. Not every core can run every type of task. This design is more common in embedded systems or specialized hardware where certain processors are dedicated to particular functions, like handling audio or managing a sensor.
Modern smartphones blend both ideas. ARM’s big.LITTLE architecture, used in most Android phones, pairs high-performance cores with energy-efficient cores on the same chip. Demanding apps run on the powerful cores, while lighter tasks like checking notifications shift to the efficient ones to save battery. This heterogeneous approach has become the industry standard for balancing speed and power consumption.
Multiprocessing vs. Multithreading
These two terms come up together constantly, and the distinction matters. Multiprocessing runs separate processes, each with its own dedicated block of memory. Multithreading splits a single process into smaller threads that all share the same memory space.
Because threads share memory, they can communicate with each other cheaply and quickly. But that shared space also creates risks: if two threads try to modify the same data at the same time, things can break in subtle ways. Separate processes in multiprocessing are more isolated from each other, which makes them more stable but more expensive. Each process gets its own copy of the program’s memory, which uses more RAM and adds overhead when processes need to exchange data. That communication typically happens through mechanisms like queues or pipes, where data is serialized, sent to the other process, and then reassembled.
In practice, most modern software uses both. A web server might spawn multiple processes for reliability (if one crashes, the others keep running), and each of those processes might use multiple threads internally for speed.
Why More Cores Don’t Always Mean More Speed
Adding processors helps only when the work can actually be split up. Every program has some portion that must run sequentially, step by step, where the next instruction depends on the result of the previous one. No amount of extra cores can speed up that sequential portion.
This principle is captured by Amdahl’s Law. If 90% of a program can be parallelized and you throw 1,024 cores at it, you get roughly a 10.9x speedup, not a 1,024x speedup. That remaining 10% of sequential work becomes the bottleneck. Even if only 1% of the program is sequential, the theoretical maximum speedup with infinite processors is 100x. And if half the program must run sequentially, adding a million processors still can’t push the speedup past 2x.
This is why software design matters as much as hardware. A program written without parallelism in mind won’t benefit from a 16-core processor any more than it would from a dual-core one. The gains from multiprocessing depend entirely on how well the workload divides into independent pieces.
Interference Between Cores
Running tasks on separate cores isn’t perfectly clean. Because cores share resources like the L3 cache, memory controllers, and the system bus, work on one core can slow down work on another. If two cores are both reading and writing large amounts of data, they compete for the same shared cache and memory bandwidth. Carnegie Mellon’s Software Engineering Institute describes this as a failure of both spatial isolation (shared memory access) and temporal isolation (one core’s activity delaying another’s).
Operating systems and chip designers use various strategies to minimize this interference, but it’s an inherent trade-off of putting multiple cores on the same chip. It’s one reason why real-world performance gains from multiprocessing are always somewhat less than the theoretical ideal.
How Your Brain Compares
The human brain offers an interesting contrast. Your sensory systems do process information in parallel: your visual cortex, auditory cortex, and motor areas all operate simultaneously without interfering with each other. Research published in The Journal of Neuroscience found that the first 250 milliseconds of processing a new stimulus unfold independently, even when you’re already working on something else.
But higher-level decision-making hits a bottleneck. When two tasks both require a conscious choice, your brain processes them one at a time. This is called the psychological refractory period, and it’s why you struggle to genuinely do two complex tasks at once. Your brain operates like a system with parallel input channels feeding into a single-threaded decision core. Sensory areas in the brain track stimuli in real time, but a network spanning the parietal and prefrontal cortex forces decisions into a queue, processing them sequentially.
In computing terms, your brain is a multiprocessor for perception but largely single-threaded for deliberate thought.