Register Now


Lost Password

Lost your password? Please enter your email address. You will receive a link and will create a new password via email.

Add post

You must login to add post .

Add question

You must login to ask a question.


Register Now

Welcome to! Your registration will grant you access to using more features of this platform. You can ask questions, make contributions or provide answers, view profiles of other users and lots more. Register now!

Part A – Multithreading & Thread Synchronization – C/C++

Part A – Multithreading & Thread Synchronization – C/C++

Price: $19.99

Welcome to the Course Series on Multi-Threading – The Master Class Course on Threads.

This course is for those who want to develop fundamental concepts on Multi-threading and related concepts. In this course, we shall be going to cover Multi-threading concepts based on Pthreads (POSIX threads) on the Linux platform.

Though We use the C language to demonstrate the concepts, concepts hold good for any programming language. This course is equally valuable for C++ programmers. Other language programmers may also find this course useful as we explain Multithreading concepts close to the ground zero levels No Abstraction.

We shall discuss several concepts involved in multithreading and demonstrate each concept through a sample program. Several Important Concepts include but not limited to – Deadlocks, Mutual Exclusion, Atomicity, Thread Synchronization, Race Conditions, Thread forking, and many more.

In the Next Installment of this course, we shall extend our knowledge of Multi-threading to Advance Concepts, including mini-projects on Multithreading and Thread Synchronization.

At each stage of this Course series, you shall be writing a lot of multi-threaded Codes. So be ready to Master the Multi-threading. Along the journey, we shall cover several interview-favorite topics and Questions to prepare you alongside for interviews.

Best of luck!

Table Of Contents:

= = = ======= = = =

1. Understanding Threads

  • Thread Creation & Termination

  • Race condition on Thread Creation

  • Passing Argument to Thread Function

  • Stack Memory Mgmt for Multi-threaded Programs

  • Thread Scheduling

2. Understanding Concurrency and Parallelism

  • Singlularism Vs Concurrency Vs Parallelism

  • Concurrent Process Design – 2 Examples

  • Threads as Light Weighted Process

  • Overlapping and Non-Overlapping Work

3. Joinable and Detached Threads

  • Joinable Vs Detached Threads

  • How to Join a thread

  • Whom to Join?

  • Sample – Map-Reduce Program

4. Inter Thread Communication

  • Understanding Callbacks and Function Pointers

  • Best way to implement ITC

  • Implementing Notification Chains

    • A Publisher Subscriber Model

    • How to Subscribe/UnSubscribe

    • How to send Notification to Subscribers

5. Asynchronous Thread Cancellation

  • Thread Cancellation

  • Asynchronous and Deferred Thread Cancellation

  • Problem with Async Thread Cancellation

    • Resource Leaking

    • Invariants

    • Deadlocks

  • Concept of Thread Cleanup Handlers

    • Prevent Resource Leaking

    • Data Structure Corruption – Invariants

    • Cancellation causing Deadlocks

6. Deferred Cancellation

  • Understanding Deferred Cancellation

  • Implementation

7. Listener Threads – Responsibility Delegation

  • Why Listener threads?

  • Designing Listener threads

  • Code Changes and Demo

  • Cancellation of blocked Threads

8. Thread Synchronization

  • Critical Section

  • Mutex Rules

  • Mutex Locking

    • Mutex Locking – Code Locking

    • Mutex Locking – Data Locking

  • Mutex based APIs

  • Mutexes in Action

9. Deadlocks

  • What are deadlocks and why do they happen?

  • Necessary conditions for Deadlock to happen

  • Mutex lock Ordering Causing Deadlocks

10. Condition Variables

  • Understanding CV

  • CV Vs Mutex

  • Wait( ) & Signal( )

  • Producer-Consumer Thread Synchronization

  • Spurious Wake Ups

  • Thread Vs Resource Specific CV

  • Broadcasting a CV

  • Implement Producer-Consumer Problem

11. Dining Philosopher Problem

  • Problem Description

  • Data Structures Setup

  • Assignment Program Setup

  • Flowchart/Algorithm Discussion

  • Final Implementation (Step by Step )

12. Semaphores

  • Introduction

  • Semaphores Vs Mutexes

  • How Semaphore work

  • Strict Alternation Problem

  • Semaphore Implementation

  • Semaphore Types

  • Strong and Weak Semaphores

Listing Upcoming Advanced Multi-Threading Topics for Sequel Course ( Under Progress )

= = = = = = = = = = = = = = = = = = = = = =

1. Pausing and Resuming Threads

2. Thread Pools

3. Standard Problems – Reader/Writer Problem

4. Implementing Thread Barriers

5. Implementing Thread Monitors

6. Solving Sync Problems using Monitors

7. Deadlock Detection and Prevention

8. Wait Queues

9. Implement Timers using Threads

10. How to fork a multi-threaded process

11. Process Synchronization using Named Semaphores

Happy Learning.


About arkadmin

Leave a reply