Imagine you’re in a bustling kitchen with multiple chefs, each juggling different tasks to create a perfect meal. Some chefs switch between tasks quickly, while others work side by side. Computers face a similar challenge when handling multiple operations. Let us explore the concepts of concurrency, parallelism, atomicity, and synchronization—all that simplifies these ideas as graspable as a well-run kitchen.

For the purposes of this technical description there are no multithreaded optimizations to processes. Each thread carries a single process. For example: Adding melted butter to 'sauce à la hollandaise'. Just like there are many steps to completing a recipe, a program may be multithreaded as we learn to run more complex tasks in a single program, some tasks are so complex that computers don't have the bandwidth to keep up. This is why we care about concurrency.

If you know anything about Computer Hardware, you’ve likely heard about companies like Nvidia. Their specialized Graphics Processing Units (GPUs) are at the heart of modern computational power, particularly in powering artificial intelligence like ChatGPT and making AAA games. But how does this relate to our kitchen? Just as a chef uses various tools and ingredients to craft a dish, a computer uses hardware innovations and software techniques to perform multiple operations at once.

Figure 1 is showing how a user manually manages tabs but is oblivious to what is happening under the hood, which is what this article is about. Since the audience is high school students I have abstracted away a lot of the prerequisites like caching, role of memory, scheduling algorithms, stacks, heaps, dynamic memory allocation, and other key concepts in understanding concurrency at a high level. Through the help of animations and analogies, I have tried to simplify basic concurrency and its C2PL optimization.

Before we get in too deep, it’s important to clarify a common misconception even among CS graduates: concurrency and parallelism are not the same thing.

2.1 Concurrency

Concurrency is like a single chef rapidly switching between multiple dishes. The chef interleaves tasks so that all the dishes make progress, even if only one task is performed at a time. In computing, concurrency is the art of managing multiple tasks that can overlap in time.

In computing terms:

• Concurrency means managing multiple tasks that overlap in time
• Only one task is actually being processed at any given moment
• The computer switches between tasks so quickly it appears simultaneous
• This is what happens when you have multiple apps open on a single-core computer

2.2 Parallelism

Parallelism happens when multiple chefs work simultaneously in the kitchen. In a computer, this is seen on multi-core processors or GPUs, where different cores handle different operations at the same time.

In computing terms:

• Parallelism means multiple tasks are literally executing at the same time
• This requires multiple processors or cores (like having multiple chefs)
• Each core handles its own task independently
• Modern computers with multiple cores can truly perform parallel operations

Understanding this difference is key to appreciating how computers juggle tasks efficiently.

3.1 The Hardware Behind the Magic

In the early days, computers were like kitchens with a single chef: one thread, one task at a time. Today's machines are much more powerful and complex:

• CPU (Central Processing Unit): The main "brain" of your computer that handles most general tasks
• Core: A processing unit within a CPU that can handle tasks independently. Modern CPUs have multiple cores (dual-core, quad-core, etc.)
• GPU (Graphics Processing Unit): A specialized processor designed to handle graphics and certain types of calculations very efficiently

Today's advanced hardware, such as Nvidia GPUs, feature thousands of tiny cores that work in parallel. Each core is capable of handling separate tasks, allowing for true parallelism and speeding up complex operations like training deep neural networks or rendering video game graphics.

In Figure 2, we see an AMD Threadripper manage concurrent tasks . It has 96 cores each capable of 2.4 billion cycles per second. This means it can perform a tremendous number of operations simultaneously.

3.2 Software’s Role: Atomicity and Synchronization

While hardware gives us the muscle, software provides the finesse. Modern programming languages and operating systems support techniques like multithreading and asynchronous programming.

What is Atomicity?

Atomicity ensures that operations happen either completely or not at all. Think of it as a chef executing a precise, uninterruptible step in a recipe. For example, when making a sauce, either all ingredients are mixed in or none are—there's no in-between state.

In computing, an atomic operation cannot be interrupted halfway through. It's all or nothing, which helps prevent data from being corrupted when multiple processes try to access it.

What is Synchronization?

Synchronization is equally important. It's like placing a "do not use" sign on a critical kitchen tool. Synchronization mechanisms (like locks) ensure that when one process is using a shared resource, no other process can interfere.

Without proper synchronization, we risk race conditions—where multiple processes access or modify data concurrently, leading to unpredictable outcomes.

Simulation A: Basic Concurrency

This simulation helps us understand at a very basic level what concurrency does. Each thread performs tasks independently of the other thread. The slider controls the time each thread takes to complete one process cycle.

• Move the slider to adjust the speed of thread execution
• The simulation updates clock speed at the next cycle
• To change the number of cores change them, then click the "Update Cores" button

"Concurrency control prevents interference among simultaneous operations in a shared environment." ^[5]

Even with the best software and hardware, chaos can ensue if multiple processes try to access the same resource simultaneously. This is known as a race condition. Race conditions are not only common, but expected when there are multiple people developing software independently, but there is a way to solve this bug.

4.1 A Kitchen Analogy for Race Conditions

Imagine two chefs in a restaurant kitchen both needing to prepare a different version of the delicious Hollandaise sauce. Chef A begins carefully balancing butter, egg yolks, and lemon juice. Before finishing, Chef B jumps in to use the sauce for their dish—unaware of Chef A’s progress—and alters it by adding extra butter. The result? A sauce with inconsistent taste and texture, much like how unsynchronized processes can produce unpredictable results in computing.

"Advanced concurrency control algorithms mitigate deadlocks and optimize performance."^[3]

4.2 The Role of Synchronization and Atomicity

To avoid such mishaps, computers use synchronization mechanisms like locks and atomic operations.
Locks: Ensure that only one process can modify a shared resource at a time.
Atomic operations: Atomic operations further guarantee that critical steps are completed fully before another process can intervene, maintaining the consistency and integrity of the data.
Simulation B illustrates some key problems in concurrency in a single timeline.

Animation1 Explanation:
The first animation is a dynamic simulation powered by GSAP (a JS library that is the industry standard for animation) that visually demonstrates how a concurrent system manages tasks using a two-phase locking (2PL) mechanism. In this animation, tasks are represented by "threads" that are created and queued, then move dynamically toward available processing cores. By the time you read this the animation might have ended, please click the run again button to run the animation again. I decided to make this a button because this animation is resource intensive. As each thread reaches its designated core area, it attempts to acquire a lock before entering a critical section—a process that simulates ensuring exclusive access to a shared resource. Once a thread successfully enters the critical section, it updates a shared counter (simulating resource use) and then eventually exits, releasing the lock for subsequent tasks. This vivid depiction helps users understand key concepts like resource contention, atomic operations, and the orderly progression of tasks in a concurrent environment.

The second animation serves as a static visual framework that complements the dynamic simulation. It renders multiple parallel tracks and a clearly defined critical section on a canvas, symbolizing the spatial pathways, along which tasks progress. These tracks represent the ordered routes that threads follow, emphasizing the underlying structure of process scheduling and resource allocation in a multi-threaded system. The critical section is highlighted to symbolize the area where resource conflicts might occur if proper synchronization is not maintained. This visualization reinforces the theoretical concepts by providing a concrete, spatial illustration of how tasks are managed and how potential contention is organized within the system. inCS is when a task is in the critical section.