Master the basics of multithreading, Pthreads, synchronization, locks, semaphores, concurrency, deadlocks from scratch.
What you'll learn
Why use threads in programs?
What are the overheads of using processes?
What is the key idea behind threads?
Difference between single vs multithreaded processes
Benefits of using threads.
Pthread basics.
How to create a thread using Pthread?
How to pass parameters to a thread?
How to use Pthread_self, Pthread_equal?
How to terminate a thread?
How to use Pthread_join to wait for a thread to terminate?
How to return values from thread functions?
How to wait for threads?
How to detach a thread using Pthread_detach?
What are global variables in threads?
What is concurrency in programs?
What are race conditions and atomic operations?
What is synchronization?
What are the correctness properties for synchronization solutions?
How to enforce mutual exclusion?
What are locks?
How to use locks in Pthreads?
How to avoid deadlock with locks?
What are semaphores?
What are synchronization patterns--bounded concurrent access, signaling?
How to employ semaphores to avoid busy waiting?
How multithreading interacts with multicores?
What are the challenges of multicore programming?
How to designing multithreaded programs?
What are thread pools?
What is the readers-writers problem?
How to solve the readers-writers problem?
What is the dining philosophers problem?
How to solve the dining philosophers problem?
What are the 4 necessary conditions for deadlocks?
How to prevent deadlocks?
What is resource allocation graph?
How to handle deadlocks?
How to implement threads?
What are user threads and kernel threads?
How are threads implemented in Linux?
How are locks implemented?
What is the TestAndSet atomic instruction?
What are spin locks?
How do locks influence performance?
Requirements
No previous knowledge about operating systems needed. Everything you need to know about the topics will be covered.
Description
Ace multithreading, Pthreads, synchronization, locks, semaphores, concurrency, deadlocks questions in competitive exams, job interviews, and OS course exams.Do you know: A single-threaded process can only execute on one core even if the machine has eight cores? A multithreaded process can exploit the true hardware parallelism! What are data races? What is process synchronization? What are atomic operations? How to implement correct multithreaded programs without data races? What are locks and semaphores? How do we use locks and semaphores to implement correct synchronization solutions? What are deadlocks? What are the necessary conditions for deadlocks? How do operating systems deal with deadlocks? How do operating systems implement threads? How do operating systems implement locks to ensure correct mutual exclusion and synchronization? Learn the explanations to these and many more intriguing questions in this course!Specifically, the course will cover the following in detail.Why use threads in programs?What are the overheads of using processes?What is the key idea behind threads?Difference between single vs multithreaded processes.Benefits of using threads.Pthread basics.How to create a thread using Pthread?How to pass parameters to a thread?How to use Pthread_self, Pthread_equal?How to terminate a thread?How to use Pthread_join to wait for a thread to terminate?How to return values from thread functions?How to wait for threads?How to detach a thread using Pthread_detach?What are global variables in threads?What is concurrency in programs?What are race conditions and atomic operations?What is synchronization?What are the correctness properties for synchronization solutions?How to enforce mutual exclusion?What are locks?How to use locks in Pthreads?How to avoid deadlock with locks?What are semaphores?What are synchronization patterns--bounded concurrent access, signaling?How to employ semaphores to avoid busy waiting?How multithreading interacts with multicores?What are the challenges of multicore programming?How to designing multithreaded programs?What are thread pools?What is the readers-writers problem?How to solve the readers-writers problem?What is the dining philosophers problem?How to solve the dining philosophers problem?What are the 4 necessary conditions for deadlocks?How to prevent deadlocks?What is resource allocation graph?How to handle deadlocks?How to implement threads?What are user threads and kernel threads?How are threads implemented in Linux?How are locks implemented?What is the TestAndSet atomic instruction?What are spin locks?How do locks influence performance?30 day money back guaranteed by Udemy.Wisdom scholarships. If you are interested in taking one of our courses but cannot purchase it, you can apply for a scholarship to enroll. Learn more about the application process at my website.
Overview
Section 1: Introduction
Lecture 1 Why use threads?
Lecture 2 Overheads of using processes
Lecture 3 Key idea behind threads
Lecture 4 Single vs multithreaded processes
Lecture 5 Benefits of threads
Section 2: Pthreads--POSIX Threads
Lecture 6 Pthread basics
Lecture 7 Creating a thread using Pthread
Lecture 8 Passing parameters to thread
Lecture 9 Pthread_self, Pthread_equal
Lecture 10 Thread termination
Lecture 11 Pthread_join--waiting for a thread to terminate
Lecture 12 Returning values from thread functions
Lecture 13 Waiting for threads
Lecture 14 Pthread_detach--detaching a thread
Lecture 15 Correct usage of pthread_join
Lecture 16 Global variables in threads
Section 3: Concurrency in programs
Lecture 17 Introduction to concurrency--nondeterminism in concurrent programs
Lecture 18 What is concurrency? An example.
Lecture 19 Race condition and atomic operations
Lecture 20 Mutual exclusion terminology and synchronization example
Lecture 21 Correctness properties for synchronization solutions
Lecture 22 Too much milk problem, approach 1
Lecture 23 Too much milk problem, approach 2
Lecture 24 Enforcing mutual exclusion
Lecture 25 Shared variables and mutual exclusion requirements
Lecture 26 Too much milk problem, approach 3
Section 4: Locks
Lecture 27 Locks
Lecture 28 Locks in Pthreads
Lecture 29 Locks in multiple critical sections
Lecture 30 Lock granularity
Lecture 31 Deadlock with locks
Lecture 32 Mutual exclusion requirements from lock based solutions
Section 5: Semaphores
Lecture 33 Semaphores
Lecture 34 More about semaphores, POSIX semaphores
Lecture 35 Synchronization patterns-bounded concurrent access, signaling
Lecture 36 Employing semaphores to avoid busy waiting
Section 6: Multithreaded programs
Lecture 37 Testing multithreaded programs
Lecture 38 Multithreading and multicores
Lecture 39 Challenges of multicore programming
Lecture 40 Multithreading and single core
Lecture 41 Designing multithreaded programs
Lecture 42 Parallel computation using multithreaded programs
Lecture 43 Thread pools
Lecture 44 Supercomputing
Section 7: Classical synchronization problems--readers-writers problem
Lecture 45 Readers-writers problem
Lecture 46 Readers-writers solution-shared data
Lecture 47 Readers-writers solution-implementation notes
Lecture 48 Readers-writers solution-writer process
Lecture 49 Readers-writers solution-reader process
Lecture 50 Readers-writes problem variations and reader-writer locks
Lecture 51 Priority in readers-writers solution
Section 8: Dining philosophers problem
Lecture 52 Dining philosophers problem
Lecture 53 Dining philosophers problem solution
Lecture 54 Deadlock in Dining philosophers solution
Lecture 55 Handling deadlock in dining philosophers solution
Section 9: Deadlocks
Lecture 56 Deadlocks--4 necessary conditions
Lecture 57 Deadlocks condition-Mutual exclusion
Lecture 58 Deadlocks conditions-Hold and wait, no preemption
Lecture 59 Deadlocks condition-circular wait
Lecture 60 Resource allocation graph and deadlocks
Lecture 61 Resource allocation graph-example 1
Lecture 62 Resource allocation graph-example 2, 3
Lecture 63 Methods for handling deadlocks
Section 10: Thread implementation
Lecture 64 Thread implementation-User and kernel threads
Lecture 65 Kernel threads
Lecture 66 Combining user and kernel threads
Lecture 67 Linux threads
Section 11: Lock implementation
Lecture 68 Lock variables
Lecture 69 TestAndSet atomic instruction
Lecture 70 Mutual exclusion using TestAndSet
Lecture 71 Spin locks
Lecture 72 Locks and performance
Anyone interested in learning about operating systems in modern computers could benefit from this course.,Computer science undergraduate students taking an operating systems course could benefit from the course.,You may (optionally) wish to print some of the material.
Screenshots

https://rapidgator.net/file/cf6cba3ed92a8708c5c625c4ad2ddd0b/Operating_system_concepts2.part1.rar.html
https://rapidgator.net/file/e19ee3e3cf2b574ab221f405ce589f58/Operating_system_concepts2.part2.rar.html
https://rapidgator.net/file/0206659f746fc66a0ae27955e51ec69e/Operating_system_concepts2.part3.rar.html

https://uploadgig.com/file/download/9447b72ec10f5EEc/Operating_system_concepts2.part1.rar
https://uploadgig.com/file/download/de49b43236a50287/Operating_system_concepts2.part2.rar
https://uploadgig.com/file/download/3895aeeF55bf3233/Operating_system_concepts2.part3.rar