Overlapping progress is not necessarily simultaneous execution
Concurrency describes a structure that handles multiple tasks whose progress overlaps in time. Parallelism describes computations actually executing at the same time. A single CPU can switch between tasks A and B and let both make progress without executing both at the same instant.
For example, B may run while A waits for incoming data. This uses waiting time even without simultaneous computation. Independent compute-heavy jobs assigned to multiple execution resources can instead overlap their actual computation. Both situations involve multiple tasks, but the property being described is different.
Separate I/O waiting from computation
Work waiting for network responses can benefit when another task progresses during the wait. Threads and event loops are possible mechanisms. In an event loop, a long blocking operation can prevent other tasks from advancing, so merely adding asynchronous syntax does not establish effective waiting behavior.
CPU-heavy work raises other questions: available resources, useful partition sizes, and the cost of coordinating results. Splitting tiny jobs too finely can make distribution and collection dominate. Increasing thread count is therefore not the same decision as increasing the computation resources a workload can actually exploit.
Describe Python with its implementation conditions
Python threading exposes a thread API, but parallel execution of CPU-bound Python code also depends on the implementation, build, GIL state, and extensions used. A conventional GIL-enabled CPython build constrains Python bytecode execution; it does not make overlapping I/O waits impossible.
Processes are another way to partition computation, with their own data-transfer and management costs. Builds capable of disabling the GIL also exist, so “Python can never execute in parallel” is too broad. Check the actual environment and the kind of work before selecting a mechanism or predicting a speedup.
Check correctness separately from performance
Tasks need not execute simultaneously to race on shared state. A switch between reading a value and writing an update can be enough. One core is not a proof of safety. Choose a coordination model, such as locks, message passing, or separated ownership, that preserves the intended update invariant.
Measure the quantities the application cares about: latency, throughput, CPU usage, or waiting time. A faster parallel portion does not accelerate serial work or eliminate communication costs. Distinguishing concurrency and parallelism helps state both the correctness question and the performance measurement instead of treating every task overlap as automatic acceleration.