Operating System Concepts-2 - Udemy

[LeeAndro]

Published 9/2022MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHzLanguage: English | Size: 1.96 GB | Duration: 4h 21m

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 teate a thread
How to use Pthread_join to wait for a thread to teate
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 patternsbounded 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 programsWhat are the overheads of using processesWhat is the key idea behind threadsDifference between single vs multithreaded processes.Benefits of using threads.Pthread basics.How to create a thread using PthreadHow to pass parameters to a threadHow to use Pthread_self, Pthread_equalHow to teate a threadHow to use Pthread_join to wait for a thread to teateHow to return values from thread functionsHow to wait for threadsHow to detach a thread using Pthread_detachWhat are global variables in threadsWhat is concurrency in programsWhat are race conditions and atomic operationsWhat is synchronizationWhat are the correctness properties for synchronization solutionsHow to enforce mutual exclusionWhat are locksHow to use locks in PthreadsHow to avoid deadlock with locksWhat are semaphoresWhat are synchronization patternsbounded concurrent access, signalingHow to employ semaphores to avoid busy waitingHow multithreading interacts with multicoresWhat are the challenges of multicore programmingHow to designing multithreaded programsWhat are thread poolsWhat is the readers-writers problemHow to solve the readers-writers problemWhat is the dining philosophers problemHow to solve the dining philosophers problemWhat are the 4 necessary conditions for deadlocksHow to prevent deadlocksWhat is resource allocation graphHow to handle deadlocksHow to implement threadsWhat are user threads and kernel threadsHow are threads implemented in LinuxHow are locks implementedWhat is the TestAndSet atomic instructionWhat are spin locksHow do locks influence performance30 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: PthreadsPOSIX 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 teation

Lecture 11 Pthread_joinwaiting for a thread to teate

Lecture 12 Returning values from thread functions

Lecture 13 Waiting for threads

Lecture 14 Pthread_detachdetaching a thread

Lecture 15 Correct usage of pthread_join

Lecture 16 Global variables in threads

Section 3: Concurrency in programs

Lecture 17 Introduction to concurrencynondeteism in concurrent programs

Lecture 18 What is concurrency An example.

Lecture 19 Race condition and atomic operations

Lecture 20 Mutual exclusion teology 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 problemsreaders-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 Deadlocks4 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.

HomePage:

Https://anonymz.com/https://www.udemy.com/course/operating-system-concepts-2/

DOWNLOAD

https://1dl.net/dqtergokjjyj/DEvabyFG__Operating_.part1.rar.html
https://1dl.net/lepap390qsi6/DEvabyFG__Operating_.part2.rar.html