Concurrency describes a system’s capability to deal with a large number of tasks that might start, run, and complete independently of each other. This is the hallmark of multi-tasking operating systems.

In contrast, parallelism revolves around performing multiple tasks simultaneously. Such systems often leverage multi-core processors.

Key Concepts

Concurrency and parallelism can coexist, but they don’t necessarily require each other. A program can be:

• Concurrenct but not parallel: e.g., a single-core processor multitasking
• Parallel but not concurrent: e.g., divided tasks distributed across multiple cores

Mechanisms

• Concurrency: Achieved through contextual task-switching. For example, using time slicing or handcrafted interruption points in the code.
• Parallelism: Achieved when the system can truly execute multiple tasks in parallel, typically in the context of multi-core systems.

Thread-Safety and Shared Resources

In a concurrent environment, multiple threads or tasks can access shared resources simultaneously. Without proper handling, this can lead to race conditions, corrupting the data.

Ensuring thread-safety involves employing strategies like:

• Locking
• Atomic Operations
• Transactional Memory
• Immutable Data
• Message Passing

Code Example: Concurrency and Parallelism

Here is the Python code:

import threading

# Two independent tasks that can run concurrently
def task_1():
    print("Starting Task 1")
    # Simulate some time-consuming work
    for i in range(10000000):
        pass
    print("Completed Task 1")

def task_2():
    print("Starting Task 2")
    # Simulate some time-consuming work
    for i in range(10000000):
        pass
    print("Completed Task 2")

# Create and start thread objects to achieve concurrency on a single-core system
thread1 = threading.Thread(target=task_1)
thread2 = threading.Thread(target=task_2)
thread1.start()
thread2.start()


# In a multi-core system, the tasks can also run in parallel
# To emulate this behavior on a single-core system, we can use:
# Python's "concurrent.futures" module.
from concurrent.futures import ThreadPoolExecutor

# Create a thread pool
executor = ThreadPoolExecutor()

# Submit the tasks for parallel execution
task1_future = executor.submit(task_1)
task2_future = executor.submit(task_2)

# Proper cleanup
executor.shutdown()