Skip to content

Latest commit

 

History

History
69 lines (42 loc) · 3.37 KB

1_ThreadSynchronization.md

File metadata and controls

69 lines (42 loc) · 3.37 KB
Raw

Thread Synchronization and Concurrency in Multi-threaded Programs 🛠️🔒

Table of Contents 📚

  1. Introduction
  2. Why is Thread Synchronization Needed?
  3. Conflicting Operations
  4. Example: Linked List Operations
  5. What Could Go Wrong
  6. Critical Sections
  7. Interview Questions
  8. Summary

Introduction 🌟

This document serves as a comprehensive guide to understanding thread synchronization, its importance, and the issues that arise in multi-threaded programs when thread synchronization techniques are not employed.

Why is Thread Synchronization Needed? ❓

Thread synchronization is essential in multi-threaded programs where multiple threads compete to perform conflicting operations on a shared resource. Without synchronization, the program can exhibit undefined behavior, data inconsistencies, or even crash.

Conflicting Operations ⚔️

  • Read-Write Operations
  • Write-Write Operations

Not Conflicting:

  • Read-Read Operations

Example: Linked List Operations 🔗

Consider a multi-threaded process P with threads T1 and T2. Both threads operate on a shared linked list of integers.

  • T1 executes a function get_node_from_list() to find a node in the linked list based on an integer value.
  • T2 executes a function delete_node_from_list() to remove a node from the list and free its memory.

What Could Go Wrong 💥

If both threads are allowed to execute without synchronization:

  1. T1 partially completes its read operation.
  2. Context-switching occurs, and T2 completes its write operation, freeing up memory.
  3. T1 resumes and attempts to access freed memory, causing a crash or undefined behavior.

Critical Sections 🚫

Areas in the code where shared data is accessed by multiple threads are called "Critical Sections". It's crucial to synchronize access to these sections to prevent data inconsistencies or crashes.

Interview Questions 🎤

What are conflicting operations in thread synchronization?

Answer: Conflicting operations are Read-Write or Write-Write operations on a shared resource. These operations can cause data inconsistencies or crashes if not synchronized properly.

Why can't you assume any determinism or pattern of scheduling of threads?

Answer: The operating system schedules threads based on its internal algorithm. Making assumptions about thread scheduling can lead to unexpected behavior, making it crucial to employ thread synchronization techniques.

What is a critical section, and why is it important?

Answer: A critical section is a piece of code where a shared resource is accessed by multiple threads. It's vital to synchronize access to critical sections to maintain data consistency and prevent crashes.

Summary 📝

Thread synchronization is essential for maintaining data consistency and avoiding undefined behaviors in multi-threaded programs. By understanding and properly implementing synchronization techniques, you can ensure the stable and reliable operation of your multi-threaded applications.

I hope these detailed notes help you in your revision for interviews! Feel free to revisit anytime for clarification. 😊👍