This article aims at providing a pedagogical understanding of the different terms associated with multithreading and concurrency. The article uses terms from Java, but the underlying concepts remain the same across all platforms.
Resource
A Resource is anything that can be used to perform a task - CPU, memory, data, and so on.
However, in the context of Concurrency, the term Resource specifically refers to state or data. These can be:
Simple data like Integers and Strings.
More complex data like Arrays and Collections.
File and Connection Handles.
Message or Work Queues.
....essentially any object that we create in a program is a resource.
Shareable Resources within a Process (that is, between the threads)
Since every process has a heap memory, resources created and stored on the Heap are shareable among its threads.
The following items are stored on the Heap in Java:
Objects
Member variables inside objects
Static variables
While resources like CPU and memory outside a process are also shareable, the focus in multithreading is on what's stored on the heap.
Atomic Operations
Operations whose all steps must be executed or none at all, are called Atomic Operations.
This implies that nothing from outside an atomic operation can read, observe or access any of its intermediate states.
Critical Section
A Critical Section is that part of a program that must be executed "atomically" - either all steps in that part execute, or none.
Such parts of a program often have shared resources and have a logical entry point and a logical exit point.
For atomic execution to hold, a thread cannot enter a critical section if another thread has already entered it and not yet exited. This is because no one else must see the intermediate state(s) of an atomic operation.
Race Condition
A race condition occurs when the order of execution of multiple threads accessing a shared resource may lead to different outcomes.
Such conditions involve at least one thread modifying the shared resource.
The core issue lies in the execution of non-atomic operations on the shared resource.
These parts of the program, as previously introduced, are the critical sections that must be identified and executed atomically.
Synchronization
Synchronization is a mechanism to ensure that multiple threads interacting with a shared resource do so harmoniously to avoid chaos, that is, unexpected outcomes.
Essentially, synchronization ensures that a single thread is allowed to access or execute actions on the shared resource at any given time.
...it's a wrap...for now...
This list is not exhaustive, and I intend to add more interesting terms as I discover them. So, anticipate the list growing over time!
Thanks!