Скачать "Операционные системы, урок 6: Дедлок. Проблема обедающих философов."

"videoThumbnail Операционные системы, урок 6: Дедлок. Проблема обедающих философов.

2:55

Категории ресурсов

4:30

Reusable (ресурсы повторного использования)

7:17

Условия возникновения дедлоков

8:20

Циклическое ожидание

8:54

Три аспекта взаимной блокировки

9:50

Предотвращение

12:07

Избегание

12:48

Два подхода к избеганию

19:34

Как это использовать?

20:39

Анализ этого подхода

26:08

Решения

Сериал I #Агай I 1-серия I Ааламга жол...

Сериал I #Агай I 1-серия I Ааламга жол...

Канал: Bairak group

Встреча с военным историком А. В. Исаевым, тема: "Сталинградская битва – новый взгляд".

Встреча с военным историком А. В. Исаевым, тема: "Сталинградская битва – новый взгляд".

Канал: Библиотека им. Н.А. Некрасова

OST #Акыркысабак I Бул жашоо – AKIRO (feat. Сырга Сагынбекова) I Премьера клипа

OST #Акыркысабак I Бул жашоо – AKIRO (feat. Сырга Сагынбекова) I Премьера клипа

Канал: Bairak group

96 - ReactJS загрузка изображения, shouldComponentUpdate fix

96 - ReactJS загрузка изображения, shouldComponentUpdate fix

Канал: IT-KAMASUTRA

HTML Атрибуты — HTML Basics: Урок 2 [Хекслет]

HTML Атрибуты — HTML Basics: Урок 2 [Хекслет]

Канал: Хекслет

63 - React JS - практика, DAL, axios.create

63 - React JS - практика, DAL, axios.create

Канал: IT-KAMASUTRA

74 - React JS - componentDidUpdate

74 - React JS - componentDidUpdate

Канал: IT-KAMASUTRA

hexlet

университет

курсы

онлайн

обучение

образование

программирование

лекции

уроки

проблема обещающих философов

дедлок

взаимная блокировка

it

os

операционныесистемы

00:00:01

Здравствуйте вы смотрите шестую лекцию

00:00:03

курса операционной системы на x.org

00:00:07

сегодня мы будем говорить о взаимной

00:00:10

блокировке или

00:00:11

локе мы познакомились с этим понятием На

00:00:14

прошлой лекции я напомню что это

00:00:16

состояние когда несколько процессов ждут

00:00:20

друг друга и не могут продолжать работу

00:00:23

потому что они ждут и так получилось что

00:00:27

они попали в некую

00:00:30

Это что-то

00:00:31

вроде проблемы курицы и

00:00:35

яйца в том примере который мы видели на

00:00:38

прошлом

00:00:39

уроке

00:00:41

используются блокировки или замки Локи и

00:00:44

процесс о блокирует какой-то ресурс пока

00:00:48

не получит

00:00:49

ресурс другой а тот другой ресурс

00:00:52

блокируется вторым процессом который в

00:00:54

такой же ситуации только наоборот ждт

00:00:56

ресурс от первого процесса и они оба

00:00:58

ждут освобождения и не могут освободить

00:01:01

ресурс потому что ждут освобождения и в

00:01:03

итоге находятся в дед локе находится в

00:01:05

взаимной блокировке и ничего полезного

00:01:07

происходить не

00:01:09

может опять же пример который мы видели

00:01:12

на прошлом уроке Это пересечение

00:01:15

неконтролируемое не управляемое

00:01:16

пересечение если нет никаких правил

00:01:18

дорожного движения есть просто две

00:01:20

дороги и четыре машины то на картинке

00:01:24

слева то состояние когда взаимная

00:01:26

блокировка возможна Вот вот она наступит

00:01:30

она может и не наступить но тут есть все

00:01:32

условия для этого и на следующей

00:01:34

картинке мы видим как все машины

00:01:36

попытались проехать куда им надо и

00:01:37

теперь ни одна машина не может ехать

00:01:39

дальше пока не проедет другая и они

00:01:43

находятся взаимной блокировке они не

00:01:44

могут выполнять полезного действия Ну и

00:01:48

возможно вы видели если живёте в городах

00:01:51

определённого направления ситуацию вроде

00:01:54

этой вот вот он самый настоящий в жизни

00:01:58

и никто ник никуда не может ехать

00:02:01

ужасно если здесь ещё как-то можно

00:02:04

физически что-то придумать Ну во-первых

00:02:06

здесь понятно что все в дед локе даже

00:02:08

если вы находитесь в машине то а

00:02:10

довольно легко понять что что случилось

00:02:12

что-то Не нехорошее и непонятное А когда

00:02:16

дело касается дедлок в операционной

00:02:18

системе то проблема ещё в том что не

00:02:20

всегда понятно что именно Deadlock перед

00:02:22

нами не всегда легко распутать эту этот

00:02:25

клубок и понять что на самом деле

00:02:27

процессы находятся во взаимной

00:02:29

блокировке потому

00:02:30

с точ зрения внешнего наблюдателя

00:02:32

процессы ждут чего-то и процессы

00:02:34

постоянно чего-то ждут процессы

00:02:35

постоянно ждут каких-то ресурсов они

00:02:37

почти никогда не получают ресурсы ровно

00:02:39

в тот момент когда им это надо и иногда

00:02:42

они ждут довольно долго и понять что они

00:02:45

когда-нибудь дождутся этого ресурса или

00:02:47

же они находятся в состоянии блокировки

00:02:50

и никогда эти ресурсы не получат не

00:02:52

всегда

00:02:58

возможно используют какие-то ресурсы и

00:03:01

когда мы говорим о блокировке мы имеем в

00:03:02

виду именно то что процессы ждут

00:03:05

какие-то ресурсы и процессы занимают

00:03:07

какие-то ресурсы и ресурсы компьютера -

00:03:10

Это всё что в нём есть всё что нужно для

00:03:12

процессов начиная от процессорного

00:03:16

времени заканчивая памятью внешними

00:03:18

устройствами или может быть даже

00:03:21

действием

00:03:23

пользователя можно выделить две

00:03:25

категории ресурсов те ресурсы которые

00:03:28

можно использовать повторно и те ресурсы

00:03:30

которые расходуются и чтобы их

00:03:32

использовать в очередной раз их нужно

00:03:35

создавать ресурсы повторного

00:03:37

использования всё ещё используются одним

00:03:39

процессом в один момент времени но они

00:03:42

не заканчиваются после того как они

00:03:44

используются после того как они заняты

00:03:47

они могут быть использованы сразу же

00:03:49

другим процессом и пример этого скажем

00:03:53

память процесс какой-то использует

00:03:56

какой-то участок памяти в этот момент

00:03:58

эту память никто другой использует не

00:04:00

может но как только он закончится этой

00:04:02

памятью Она сразу станет доступной

00:04:04

другой другим процессом и по аналогии с

00:04:08

перекрёстком и машиной это Дорога дорога

00:04:12

может быть занята по ней может ехать

00:04:14

машина но когда она не занята её можно

00:04:16

использовать её не нужно создавать

00:04:17

каждый раз чтобы её использовать

00:04:19

расходуемые расходуемые ресурсы нужно

00:04:22

создавать перед использованием они

00:04:24

используются и они грубо говоря

00:04:27

уничтожаются в момент этого

00:04:28

использования

00:04:30

так вот reusable или ресурсы повторного

00:04:33

использования - это файлы базы данных

00:04:36

какие-то семафоры сам Центральный

00:04:38

процессор естественно и когда процессы

00:04:41

используют такие ресурсы то взаимная

00:04:44

блокировка возможна если процесс

00:04:46

использует один ресурс и запрашивает

00:04:48

новый ресурс и это то о чём мы говорили

00:04:52

в прошлый раз какой-то процессор

00:04:54

использует ресурс ему нужен другой

00:04:56

ресурс А этот другой ресурс использует с

00:04:58

каким-то другим процессом

00:05:00

и получается процесс ждт освобождения

00:05:04

какого-то ресурса при этом собственный

00:05:05

ресурс у него занят и этот его

00:05:07

собственный ресурс в какой-то момент

00:05:09

может понадобиться другому

00:05:12

процессу те же ресурсы которые являются

00:05:15

расходуемые их примеры - это прерывание

00:05:18

процессора или сигналы или сообщения

00:05:21

которые процессы посылают друг другу в

00:05:24

прошлой лекции мы не говорили о способе

00:05:27

коммуникации между процессами

00:05:29

Представьте себе что процессы могут

00:05:31

отправлять друг другу сообщения вроде

00:05:33

имело или СМСок и они делают Это для

00:05:36

того чтобы как-то синхронизировать

00:05:38

работу чтобы рассказать друг другу о том

00:05:40

что происходит чтобы можно было делать

00:05:43

какую-то общую работу и сообщения эти

00:05:46

могут посыла и могут приниматься

00:05:49

возможно в какой-то момент процесс ждёт

00:05:51

сообщения от другого процесса он ждёт

00:05:53

это письмо и он не может продолжать

00:05:55

работу и в таком случае взаимная

00:05:58

блокировка тоже возможна Потому что если

00:06:00

процесс ожидания сигнала является

00:06:02

блокирующим То есть если процесс

00:06:04

останавливается и ждёт сообщения и

00:06:06

ничего дальше не делает то возможно

00:06:08

взаимная блокировка если то сообщение

00:06:11

которое он ждёт не может быть отправлено

00:06:13

потому что другой процесс тоже чего-то

00:06:15

ждёт и в какой-то момент цикл замыкается

00:06:18

и все ждут сообщения друг о друга И

00:06:20

никто ничего не

00:06:22

делает Это расходуемые ресурсы потому

00:06:25

что после того как сообщение отправлено

00:06:27

получено и использовано его нельзя

00:06:30

использовать ещё раз А если нужно

00:06:32

отправить новое сообщение то это будет

00:06:34

реально новое

00:06:37

сообщение и вот простой пример А у нас

00:06:40

есть два процесса первый процесс ждёт

00:06:42

сообщение от второго процесса после чего

00:06:44

пошлёт ему какое-то сообщение а но это

00:06:47

сообщение от второго процесса никак не

00:06:49

приходит Потому что сам второй процесс

00:06:51

ждёт аналогичного сообщения от первого

00:06:53

процесса но мы знаем что сообщение от

00:06:55

первого процесса не придёт пока первый

00:06:57

процесс не получит сообщение от второго

00:06:59

и оба процесса ждут друг друга и ничего

00:07:02

не делают в целом это конечно же Похоже

00:07:04

на то как они ждут освобождения ресурса

00:07:07

и не важно используем неважно Можно ли

00:07:09

этот ресурс использовать повторно или

00:07:11

нет суть всегда в том что они ждут друг

00:07:13

друга ждут какого-то действия друг от

00:07:17

друга Мы говорили о том что есть четыре

00:07:21

условия возникновения взаимной

00:07:23

блокировки или

00:07:25

дедка во-первых в системе

00:07:28

должна быть система взаимной взаимного

00:07:31

исключения Это должно поддерживаться как

00:07:33

минимум на уровне операционной

00:07:36

системы должно быть такое понятие опять

00:07:39

же поддерживаться на уровне процессов

00:07:41

как Hold and Weight или процесс

00:07:43

блокирует ресурс И ждёт освобождения

00:07:44

другого это то о чём мы говорили процесс

00:07:47

использует какой-то ресурс и не отдаёт

00:07:49

его пока не закончит с ним А в какой-то

00:07:52

момент ему нужен новый ресурс и пока он

00:07:55

ждёт Этот новый ресурс Он всё ещё

00:07:57

занимает тот старый ресурс

00:08:00

система не должна иметь возможности

00:08:03

отбирать ресурсы у процесса пока он сам

00:08:05

не завершится ну и циклическое

00:08:09

ожидание должно быть в системе возможным

00:08:13

если все эти условия соблюдены то в

00:08:16

системе в какой-то момент может

00:08:17

возникнуть взаимная

00:08:19

блокировка циклическое ожидание простая

00:08:22

иллюстрация У нас есть ресурсы и есть

00:08:25

процессы и первый ресурс используется то

00:08:28

есть в данный момент заблокирован

00:08:30

процессом о но этот процесс о хочет

00:08:33

ресурс 2 ресурс 2 он получить не может

00:08:36

потому что он сейчас используется

00:08:38

процессом 2 ну и так далее и последний

00:08:41

процесс хочет первый ресурс А тутто И

00:08:44

замыкается этот цикл и все четыре

00:08:47

процесса владеют какими-то ресурсами

00:08:49

хотят какие-то новые ресурсы и никто

00:08:51

ничего не может

00:08:55

сделать когда говорим вмро операционной

00:09:00

системе То есть три

00:09:02

аспекта самое наверное на первый взгляд

00:09:06

очевидное это нужно сделать так чтобы

00:09:08

взаимной блокировки не было нужно

00:09:11

предотвратить вообще такую возможность

00:09:15

предотвратить условия при которых

00:09:17

взаимная блокировка может

00:09:20

появиться другой Аспект - это

00:09:23

избегания можно делать так чтобы мы

00:09:27

всегда следили за нашими действиями и

00:09:29

всегда следили чтобы наш следующий шаг

00:09:31

не привёл к взаимной

00:09:33

блокировке Ну и последний Аспект - это

00:09:36

обнаружение

00:09:37

а возможно взаимная блокировка где-то в

00:09:41

какой-то момент появится и большая

00:09:43

проблема становится обнаружение этой

00:09:46

взаимной блокировки как я говорил это не

00:09:48

всегда

00:09:49

очевидно Итак давайте поговорим про

00:09:52

предотвращение взаимной

00:09:54

блокировки можно выделить два типа

00:09:56

предотвращения дедка ко

00:09:59

пр косвенное - это сделать так чтобы не

00:10:03

было условий чтобы взаимная блокировка

00:10:05

не могла теоретически случиться

00:10:09

и для этого Мы помним эти

00:10:12

четыре условия нужно сделать так чтобы

00:10:15

из первых трёх

00:10:17

условий первые три условия не могли

00:10:19

выполниться

00:10:20

одновременно то есть Взаимно исключение

00:10:23

должно поддерживаться на уровне

00:10:24

операционной систе

00:10:29

все необходимые ресурсы одновременно и

00:10:32

отбор ресурсов системой то есть процесс

00:10:34

должен освободить ресурс и запросить его

00:10:36

снова для примера Если со взаимным

00:10:39

исключением понятно Это должно

00:10:41

поддерживаться на уровне операционной

00:10:43

системы то с holden Weight всё чуть

00:10:48

менее

00:10:50

Понятно нам нужно сделать так чтобы

00:10:52

процесс запрашивал все необходимые

00:10:54

ресурсы в самом начале чтобы он в

00:10:57

процессе своей работы

00:10:59

не решал вдруг что ему Нужен какой-то

00:11:01

ресурс тогда на момент запуска мы будем

00:11:04

знать что вот эти ресурсы ему нужны для

00:11:06

завершения и он точно завершится если мы

00:11:08

ему эти ресурсы сейчас

00:11:12

дадим насчёт отбора тут всё немного

00:11:15

проще

00:11:17

А если процесс использует какой-то

00:11:19

ресурс то в какой-то момент он должен

00:11:21

его освободить и запросить снова и это

00:11:23

может не совсем логично смысл этого этой

00:11:27

операции Смысл в том что когда он его

00:11:29

запросит снова возможно он его не

00:11:31

получит сразу же он должен его

00:11:33

освободить и Дать шанс другим процессам

00:11:35

использовать его возможно он получит его

00:11:38

почти сразу и будет всего лишь небольшая

00:11:41

задержка но зато он даст шанс другим

00:11:44

процессам использовать этот

00:11:48

ресурс прямое предотвращение взаимной

00:11:50

блокировки - это просто запретить

00:11:52

циклическое ожидание сделать так что

00:11:54

циклическое ожидание невозможно сделать

00:11:58

так чтобы когда

00:12:00

начинает запрашивать ресурс Мы проверяли

00:12:02

не Привет ли это к возникновению

00:12:04

циклического

00:12:07

ожидания второй Аспект взаимной

00:12:10

блокировки - это избегание

00:12:13

И тут нужно просто следить за каждым

00:12:16

своим шагом мы смотрим на нашу ситуацию

00:12:19

и пытаемся понять может ли она привести

00:12:22

к взаимной блокировки в будущем ли у на

00:12:24

предс к этому

00:12:28

для запросы процессы будут делать в

00:12:31

будущем Какие ресурсы Какие процессы

00:12:33

захотят в ближайшем будущем И если мы

00:12:37

знаем эту информацию Если процессы нам

00:12:38

предоставят эту информацию то мы можем

00:12:40

примерно определить Могут ли эти запросы

00:12:44

привести к возникновению

00:12:48

дедлок к избеганию есть два

00:12:52

подхода во-первых можно запретить

00:12:54

процессу который может привести к

00:12:56

взаимной блокировке вообще запускаться

00:12:59

То есть если процесс запускается он

00:13:03

говорит мне нужны вот такие-то ресурсы

00:13:05

мы оцениваем ситуацию и

00:13:07

понимаем возможно из-за этого процесса

00:13:10

возникнет

00:13:11

взаимная блокировка и мы просто

00:13:16

отказываемся при этом это не факт что

00:13:20

этот процесс приведёт к взаимной

00:13:22

блокировке это просто возможность мы

00:13:24

отме таем эту возможность то есть мы

00:13:26

рассчитываем на самый худший сценарий

00:13:28

это что-то вроде не пускать ребёнка на

00:13:30

улицу потому что он может сломать ногу

00:13:33

да В итоге он Ока окажется в

00:13:35

безопасности и ногу точно не сломает но

00:13:37

это не оптимальный вариант у этого

00:13:40

варианта много проблем и в целом это

00:13:42

несправедливо по отношению к ребёнку

00:13:44

А есть второй подход запт запрет

00:13:48

предоставления ресурсов если это может

00:13:50

привести к взаимной блокировке то есть

00:13:53

мы даём всем процессам запускаться Мы не

00:13:55

отказываемся в запуске но мы можем

00:13:57

отказать процессу в ресурсе в какой-то

00:14:00

момент и чтобы понять Как это можно

00:14:03

сделать рассмотрим алгоритм банкира так

00:14:08

называемый Итак Представьте что у нас

00:14:12

есть банк и мы будем говорить что мы это

00:14:14

банк Ну или я это банк и в банке есть

00:14:17

некоторое количество денег и есть

00:14:18

несколько человек которые хотят взять

00:14:20

эти деньги в долг что-то сделать с ними

00:14:23

и верну эти

00:14:25

Деги допустим

00:14:29

есть 32 доллара и Наша задача

00:14:32

естественно обслужить этих людей чтобы

00:14:33

они сделали свои дела чтобы они смогли

00:14:35

воспользоваться этими деньгами и вернули

00:14:37

нам эти деньги естественно в этой

00:14:39

аналогии люди которые запрашивают деньги

00:14:42

- Это

00:14:43

ресурсы А деньги это и есть ресурсы Я

00:14:47

извиняюсь люди которые запрашивают

00:14:49

деньги - это процессы

00:14:52

А деньги - Это

00:14:54

ресурсы то есть Банк - это операционная

00:14:57

система И она пытается раздать

00:15:00

ресурсы компьютера этим процессом чтобы

00:15:02

всё получилось чтобы они сделали своё

00:15:04

дело но одновременно Мы это сделать не

00:15:06

можем нам у нас нет денег чтобы

00:15:08

обслужить всех сразу поэтому мы должны

00:15:11

подумать В какой в каком

00:15:14

порядке раздать деньги чтобы все

00:15:16

оказались Счастливы все смогли сделать

00:15:18

свои дела допустим первый человек хочет

00:15:21

23 доллара второй человек хочет 9

00:15:24

долларов и третий человек хочет 18

00:15:26

долларов в сумме это 50 долларов у нас в

00:15:29

банке 50 долларов Нет мы не можем Сразу

00:15:31

всех обслужить поэтому мы начинаем

00:15:33

раздавать деньги в определённом порядке

00:15:36

Допустим мы дали первому человеку 15

00:15:39

долларов второму п и третьему во у нас

00:15:41

осталось 4 доллара при этом первый

00:15:45

человек всё ещё не может завершить свою

00:15:47

задачу потому что ему не хватает 8

00:15:49

долларов второму человеку не хватает 4

00:15:52

долларов и третьему человеку не хватает

00:15:54

10

00:15:56

долларов у нас в банке осталось только 4

00:15:59

доллара и нам нужно сделать так чтобы

00:16:02

все оказались

00:16:04

счастливы человек сможет вернуть деньги

00:16:07

только если он получит всю сумму и

00:16:09

пройдёт некоторое время он получит всю

00:16:11

сумму он сделает что-то И потом вернёт

00:16:14

нам эти деньги мы сможем их снова

00:16:17

использовать Давайте оценим эту

00:16:19

обстановку это типичная обстановка в

00:16:21

операционной системе когда некоторые или

00:16:24

даже большая часть ресурсов используется

00:16:27

процессы заняли эти ресурс Они что-то с

00:16:29

ними делают но они ещ не завершены они

00:16:32

ещ не могут их освободить они не

00:16:34

закончили чтобы закончить им нужны ещё

00:16:36

какие-то ресурсы и они ждут этих

00:16:41

ресурсов посмотрим на эту ситуацию У нас

00:16:43

есть 4 доллара и Можем ли мы сделать

00:16:47

что-то Можем ли мы сейчас продолжить

00:16:50

работу всей этой системы мы не можем

00:16:52

обслужить первого человека ему нужно 8

00:16:54

долларов У нас их нет мы не можем

00:16:57

обслужить третьего человека ему нужно 10

00:17:00

долларов у нас всего че но мы можем

00:17:02

обслужить второго человека ему нужно 4

00:17:05

доллара и у нас есть ровно 4 доллара Это

00:17:08

значит что среди всех этих людей есть

00:17:11

хотя бы один которого мы можем обслужить

00:17:14

есть хотя бы один процесс который может

00:17:17

продолжить свою работу поэтому такое

00:17:19

состояние системы называется

00:17:22

безопасным это состояние в котором дедка

00:17:25

нет в котором мы можем продолжить

00:17:27

работу поэтому давайте сделаем это а но

00:17:30

перед этим посмотрим как возможно

00:17:32

небезопасное

00:17:33

состояние Представьте что первому

00:17:35

человеку мы дали не 15 как в этом

00:17:38

примере а 16 долларов и ему всё ещё надо

00:17:42

семь при этом у нас осталось 3

00:17:45

доллара в этой ситуации мы не можем

00:17:48

ничего сделать у нас нет денег чтобы

00:17:50

обслужить ни одного из этих людей и все

00:17:53

они ждут этих денег и никто из них не

00:17:56

может вернуть сумму пока не получит

00:17:57

полную сумму которую нуж Мы в

00:18:00

небезопасном состоянии и мы не можем

00:18:02

ничего

00:18:03

делать Давайте вернёмся к безопасному

00:18:05

состоянию у нас всё же есть 4 доллара и

00:18:08

мы обслужи второго человека мы ему дадим

00:18:10

эти 4 доллара Итого он получит все де

00:18:14

долларов которые он хотел и в какой-то

00:18:16

момент использует их и вернёт нам он

00:18:21

счастлив он закончил это процесс который

00:18:24

закончил свою работу и может может быть

00:18:26

уничтожен

00:18:29

долла и мы снова оцениваем ситуацию Мы в

00:18:33

безопасном состоянии потому что мы можем

00:18:36

обслужить ещё одного человека мы можем

00:18:38

обслужить первого человека ему нужно 8

00:18:40

долларов мы ему даём 8 долларов он

00:18:42

получает всю сумму которая ему нужна

00:18:44

опять же её использует и возвращает нам

00:18:47

в банк теперь у нас 24 доллара в банке и

00:18:50

два из трх людей завершили свои

00:18:54

делать одного

00:18:59

можем дать 10

00:19:03

долларов я тут немножко спутал с цифрами

00:19:06

но я думаю вы поняли суть он тоже эти

00:19:09

деньги использует возвращает нам и мы

00:19:12

остаёмся в том состоянии с которого мы

00:19:15

начали только теперь все обслужены все

00:19:17

счастливы и деньги вернулись в банк и

00:19:21

это примерно то что может использовать

00:19:23

операционная система для того чтобы

00:19:25

оптимально распределить ресурсы между

00:19:27

процессами так чтобы это не привело кло

00:19:30

так чтобы это не привело к небезопасно

00:19:34

состоянию Ну и как использовать эту идею

00:19:36

Как использовать этот

00:19:39

алгоритм Каждый раз когда процесс

00:19:41

запрашивает ресурс мы будем допускать

00:19:43

что мы ему даём этот

00:19:47

ресурс просто

00:19:49

воображая операционная система

00:19:51

воображает Окей я дам то что он просит у

00:19:54

меня что же

00:19:57

полу симулировать Что произойдёт с

00:20:01

состоянием системы в каком состоянии

00:20:04

система

00:20:05

окажется Если система окажется в

00:20:08

безопасном состоянии то всё нормально

00:20:10

Это значит что этот шаг Безопасен и

00:20:12

после него можно будет продолжать работу

00:20:14

тогда этот ресурс можно предоставить

00:20:16

процессу Если же по этой симуляции

00:20:19

окажется что система попадёт в

00:20:22

небезопасное состояние Это значит что

00:20:25

естественно ресурс давать нельзя если мы

00:20:27

дадим этот ресурс то мы окажемся в

00:20:40

дедлокед есть конечно же и плюсы и

00:20:42

минусы плюс в том что нам не нужно

00:20:44

отбирать ресурсы Мы просто не даём

00:20:46

ресурсы если мы знаем что это приведёт к

00:20:48

каким-то негативным последствиям и здесь

00:20:51

намного меньше ограничений по сравнению

00:20:53

с предотвращением взаимной блокировки

00:20:55

помните в предотвращении мы рассчитывали

00:20:57

на худший вариант и не давали процессу

00:20:59

запуститься если он теоретически может

00:21:02

привести к чему-то плохому здесь мы даём

00:21:05

процессам запуститься но можем не дать

00:21:07

им ресурсы если мы точно знаем что они

00:21:09

приведут к а небезопасном

00:21:13

состоянию минусы здесь в том что нам

00:21:15

нужно больше знать о процессах нам нужно

00:21:17

ть максимальное количество необходимых

00:21:19

ресурсов в этой аналогии с банком всё

00:21:22

было просто потому что мы точно знали

00:21:23

Сколько денег нужно каждому человеку Мы

00:21:25

точно знали что эту сумму а

00:21:28

как только мы эту сумму дадим в какой-то

00:21:31

момент мы вернём её мы получим её

00:21:33

обратно с процессами не всегда всё так

00:21:35

просто процессы не всегда заранее могут

00:21:37

сказать сколько ресурсов им надо поэтому

00:21:39

мы можем рассчитывать на одно окажется

00:21:41

что им нужно чуть больше ресурсов и

00:21:44

безопасное состояние о котором мы Ну и

00:21:46

процесс не может завершиться пока он

00:21:48

владеет ресурсом в этом вся суть

00:21:52

идеи третий Аспект о котором мы почти не

00:21:56

будем говорить это обнаружение

00:22:01

в противоположности предотвращению где

00:22:03

ничего нельзя здесь можно всё но всегда

00:22:06

нужно следить за состоянием всегда нужно

00:22:08

следить за тем

00:22:10

чтобы если делок произошёл то нужно его

00:22:14

как-то как-то обнаружить

00:22:16

и выйти из этой

00:22:20

ситуации

00:22:21

Окей с этим вроде ВС

00:22:24

понятно Давайте те под коне лекции

00:22:27

поговорим леме обедающих

00:22:30

философов это

00:22:32

проблема это иллюстрация той проблемы

00:22:35

которая возникает в операционной системе

00:22:37

и в принципе во многих других аспектах

00:22:39

жизни представьте себе стол и пять

00:22:44

философов которые сидят за этим

00:22:47

столом напротив каждого философа лежит

00:22:49

По тарелке с макаронами Ну или с

00:22:52

какой-то едой и у нас есть пять вилок

00:22:55

которые лежат между этими тарелками

00:22:59

философы делают в любой момент времени

00:23:02

одну из двух вещей или они сидят и

00:23:05

думают и ничего не делают физически или

00:23:08

они хотят кушать и начинают

00:23:11

кушать естественно это люди Так что если

00:23:14

они не будут кушать очень долгое время

00:23:17

то они погибнут от

00:23:19

голода Проблема в том что чтобы кушать

00:23:23

философу нужны обе вилки ему нужна вилка

00:23:26

и слева и справа

00:23:29

и естественно из количества вилок здесь

00:23:31

можно понять что одновременно они кушать

00:23:33

точно не смогут вилок просто на всех не

00:23:36

хватит но теоретически они могут выжить

00:23:39

теоретически они могут сделать так что

00:23:42

все покушали и никто не

00:23:45

голодает проблема в том что они не могут

00:23:47

общаться между собой они молчаливые они

00:23:49

могут или думать или захотеть

00:23:52

кушать и у них должны быть какие-то

00:23:54

правила они просто заранее должны

00:23:55

договориться как они

00:23:57

будут будет поднимать вилки если они ни

00:24:00

о чём не договорятся то просто в

00:24:02

какой-то момент э кто-то начнёт кушать

00:24:05

кто-то другой может захотеть кушать и

00:24:07

тот кто будет ждать освобождения вилки

00:24:10

может погибнуть от

00:24:12

голода здесь две проблемы а взаимная

00:24:16

блокировка или Deadlock и ресурсное

00:24:18

голодание в более чем прямом смысле

00:24:21

голодание представьте себе ситуацию

00:24:23

когда каждый из философов берёт скажем

00:24:27

левую от себя вилку

00:24:29

все они подняли по левой вилке но никто

00:24:32

не может кушать потому что чтобы кушать

00:24:34

нужно взять обе вилки но все вилки уже

00:24:37

подняты нет ни одной свободной вилки

00:24:40

каждый философ поднял левую вилку и ждёт

00:24:42

когда же освободится вилка справа от

00:24:45

него но вилка справа от него не

00:24:47

освободится потому что её поднял

00:24:48

следующий философ и тоже ждёт вилки

00:24:50

справа от себя это самый типичный все

00:24:54

они ждут освобождения какого-то ресурса

00:24:57

и освободить собственный ресурс потому

00:24:59

что они

00:25:01

ждут в итоге они будут сидеть пока не

00:25:04

погибнут от

00:25:05

голода ресурсное голодание Возможно если

00:25:09

какие-то философы кушают какие-то

00:25:11

философы используют вилки но какие-то

00:25:15

другие философы по стечению

00:25:17

обстоятельств никак не могут получить

00:25:19

обе вилки допустим философ слева и

00:25:22

философ справа вот эти два постоянно

00:25:25

кушают используют свои

00:25:27

вилки

00:25:29

фиф Ну или допустим этот философ кушает

00:25:31

потом кушают вот эти

00:25:33

два оставшиеся два философа никак не

00:25:36

могут успеть за ними никак не могут

00:25:38

успеть взять вилки они постоянно

00:25:40

переключаются между собой и два философа

00:25:43

могут погибнуть от голода И

00:25:45

это проблема ресурсного голодания с

00:25:48

процессами в операционной системе может

00:25:50

случаться тоже самое когда какие-то

00:25:52

ресурсы

00:25:53

используются какими-то процессами иги

00:25:56

про

00:25:58

ждут и Ну никак не могут получить нужный

00:26:00

ресурс в операционной системе Есть

00:26:02

множество инструментов для решения этих

00:26:04

проблем Что же делать философом Ну тут

00:26:09

есть несколько возможных решений самое

00:26:11

простое и самое очевидное - это включить

00:26:13

дополнительного человека некого судью

00:26:15

или официанта который будет следить за

00:26:18

всем этим который знает состояние всей

00:26:19

системы который знает какие вилки сейчас

00:26:21

используются какие нет и он используется

00:26:24

как

00:26:25

семафор по аналогии с процессами

00:26:29

правило здесь в том что философ должен

00:26:31

спросить у официанта разрешения Можно ли

00:26:33

ему поднять вилку справа или можно ли

00:26:36

ему поднять вилку слева официант всегда

00:26:38

знает что происходит поэтому он будет

00:26:40

принимать здравые решения так чтобы все

00:26:42

смогли

00:26:44

покушать это дополнительный Агент это

00:26:47

если мы опять же возвращаемся к

00:26:48

операционной системе и процессам и

00:26:51

управлению процессами это дополнительная

00:26:53

задача для операционной системы это

00:26:55

дополнительный процесс для операционной

00:26:57

системы это дополнительная нагрузка на

00:26:59

весь

00:27:02

компьютер

00:27:03

другая Другое решение возможное - это

00:27:06

так называемая иерархия ресурсов

00:27:08

Представьте что

00:27:10

мы дали каждой вилке номер вот эта вилка

00:27:13

номер один это вилка номер два 3 4 и 5 и

00:27:18

философам мы дали такое правило если вы

00:27:21

хотите покушать вам всё ещё нужно обе

00:27:24

вилки но поднимать вилки Вы можете

00:27:27

только в порядке увеличения то есть

00:27:29

Сначала вы должны поднять вилку с

00:27:31

меньшим номером а потом поднять вилку с

00:27:34

большим номером если они начнут это

00:27:36

делать допустим вот этот философ

00:27:38

поднимет сначала вилку слева от себя

00:27:40

потом

00:27:41

справа следующий философ не сможет

00:27:44

поднять свою правую вилку потому что ему

00:27:46

нужно сначала поднять левую но левая

00:27:48

недоступна поэтому он ничего не будет

00:27:50

делать следующий философ сможет поднять

00:27:52

свои Две вилки и в итоге эти два

00:27:54

философа смогут кушать

00:27:59

есть ещё возможные решения допустим есть

00:28:02

решени когда философы кушают по очереди

00:28:05

они просто кушают допустим против

00:28:07

часовой стрелки сначала этот потом

00:28:08

следующий потом следующий и так далее

00:28:11

Если же разрешить философам общаться

00:28:13

между собой то может получиться довольно

00:28:16

умная система самоорганизации когда им

00:28:18

не нужен ни не нужны дополнительные

00:28:21

правила и не нужен официант или хозяин и

00:28:23

они могут сами между собой договориться

00:28:25

Ну в оригинальной постановке задачи

00:28:28

об между

00:28:30

собой Вот такие

00:28:33

дела Я надеюсь вам понравилось если вам

00:28:35

интересна эта тема Вы можете почитать

00:28:37

про проблему обедающих философов и

00:28:40

несколько нетривиальных

00:28:43

решений есть решение на самом деле

00:28:46

котором буквально 2 года хотя сама

00:28:49

задача была

00:28:50

придумана для визуализации этих проблем

00:28:53

в операционных системах е в середине

00:28:57

века естно то Погугли или почитайте для

00:29:00

начала

00:29:01

Википедии английская версия этой статьи

00:29:04

более Широкая Так что советую начать

00:29:06

именно с

00:29:07

неё Спасибо за внимание и увидимся на

00:29:10

следующей неделе

Описание:

Автор: Рахим Давлеткалиев (https://rakh.im/) Пройдите доп тесты на закрепление материала (это бесплатно): https://ru.hexlet.io/courses/operating_systems

Готовим варианты загрузки

Популярные

HD видео

Только звук

Все форматы

* — Если видео проигрывается в новой вкладке, перейдите в неё, а затем кликните по видео правой кнопкой мыши и выберите пункт "Сохранить видео как..."

** — Ссылка предназначенная для онлайн воспроизведения в специализированных плеерах

Вопросы о скачивании видео

Как можно скачать видео "Операционные системы, урок 6: Дедлок. Проблема обедающих философов."?

Сайт http://unidownloader.com/ — лучший способ скачать видео или отдельно аудиодорожку, если хочется обойтись без установки программ и расширений. Расширение UDL Helper — удобная кнопка, которая органично встраивается на сайты YouTube, Instagram и OK.ru для быстрого скачивания контента.
Программа UDL Client (для Windows) — самое мощное решение, поддерживающее более 900 сайтов, социальных сетей и видеохостингов, а также любое качество видео, которое доступно в источнике.
UDL Lite — представляет собой удобный доступ к сайту с мобильного устройства. С его помощью вы можете легко скачивать видео прямо на смартфон.

Какой формат видео "Операционные системы, урок 6: Дедлок. Проблема обедающих философов." выбрать?

Наилучшее качество имеют форматы FullHD (1080p), 2K (1440p), 4K (2160p) и 8K (4320p). Чем больше разрешение вашего экрана, тем выше должно быть качество видео. Однако следует учесть и другие факторы: скорость скачивания, количество свободного места, а также производительность устройства при воспроизведении.

Почему компьютер зависает при загрузке видео "Операционные системы, урок 6: Дедлок. Проблема обедающих философов."?

Полностью зависать браузер/компьютер не должен! Если это произошло, просьба сообщить об этом, указав ссылку на видео. Иногда видео нельзя скачать напрямую в подходящем формате, поэтому мы добавили возможность конвертации файла в нужный формат. В отдельных случаях этот процесс может активно использовать ресурсы компьютера.

Как скачать видео "Операционные системы, урок 6: Дедлок. Проблема обедающих философов." на телефон?

Вы можете скачать видео на свой смартфон с помощью сайта или pwa-приложения UDL Lite. Также есть возможность отправить ссылку на скачивание через QR-код с помощью расширения UDL Helper.

Как скачать аудиодорожку (музыку) в MP3 "Операционные системы, урок 6: Дедлок. Проблема обедающих философов."?

Самый удобный способ — воспользоваться программой UDL Client, которая поддерживает конвертацию видео в формат MP3. В некоторых случаях MP3 можно скачать и через расширение UDL Helper.

Как сохранить кадр из видео "Операционные системы, урок 6: Дедлок. Проблема обедающих философов."?

Эта функция доступна в расширении UDL Helper. Убедитесь, что в настройках отмечен пункт «Отображать кнопку сохранения скриншота из видео». В правом нижнем углу плеера левее иконки «Настройки» должна появиться иконка камеры, по нажатию на которую текущий кадр из видео будет сохранён на ваш компьютер в формате JPEG.

Сколько это всё стоит?

Нисколько. Наши сервисы абсолютно бесплатны для всех пользователей. Здесь нет PRO подписок, нет ограничений на количество или максимальную длину скачиваемого видео.