многозадачность операционной системы windows это

Многозадачность ОС в разрезе системы массового обслуживания

Мне бы хотелось рассказать немного о многозадачности операционной системы. О концепте управления процессами и потоками с точки зрения ОС (и процессора/процессоров) как системы массового обслуживания. О том, «как это происходит».

Процессов ведь много, а ресурсы ограничены. На всех сразу не хватает. Что же делать? И вот тут возникает аналогия с системой массового обслуживания. Можно представить пул процессов как очередь в кассу. Ой, простите, в процессор. И архаичных вариантов обработки такой очереди [мне известно] три.

Предислование

Изначально я буду ориентироваться на то, что процессор один. Для упрощения. Потом расскажу, в чем, на мой, взгляд разница.

Для начала: общие сведения.

Картинка процессора

Что же такое «процесс» и в чем его отличие от «потока»? Процесс — это (грубо говоря) — заявка на реализацию чего-либо. Точнее, на потребление системных ресурсов. ОС генерирует системную информацию, в которой говорит, какие необходимы это процессу ресурсы. А так же о тех ресурсах, которые ему фактически были выделены. И это — для каждого вновь создаваемого процесса отдельно. О том, сколько ему необходимо памяти, сколько процессорного времени, и т.д.

Так о чем же я? Ах, да.

О способах обработки очереди процессов

Архаичных способов обработки очереди, как я говорила, мне известно три.

Т.е., каждому процессу выделяется определенный квант времени, после которого процессор радостно рапортует: «Свободная касса!», и получает на обслуживание следующий процесс. Текущий процесс же идет в конец очереди. Ибо «все равны». Недостатки: (грубый пример) у Вас идет видеоконференция. Очень важная. Прямо на самом интересном месте: бабах! И начинает печатается «важный» документ. Он же письмо с просьбой перенести время доставки ежедневного обеда с 13:00 на 14:00. А Ваша видеоконференция «неизвестно когда» будет возобновлена. Конечно, на практике так не бывает, потому что принтер работает по прерыванию, и там вообще все иначе. Но аналогия, мне кажется, в целом ясна.

Это когда «не все равны». Процессу назначается приоритет, и пока процесс с более высоким приоритетом не будет обслужен (ой, простите, обработан), другие к кассе (ой, простите, к процессору) подойти не смогут. Недостатки: могут быть процессы, которые из-за низкого приоритета не обработаются вообще никогда. Т.е., письмо Вы так никогда и не распечатаете.

На практике же зачастую используется подход «все равны, но некоторые ровнее». Т.е., «смешанный». Когда процессу выделяется квант времени и приоритет одновременно. Тогда процесс уходит не в конец очереди, а куда-то в «свою» середину. И там ждет.

Схема ясна, но как же обрабатываются процессы? В какой очередности? Тут все та же система массового обслуживания. Есть несколько подходов к обработке процессов в случае квантования и «смешанного» типа:
— FIFO. Первый пришел, первый вышел. (First-In-First-Out)
— LIFO. Последний пришел, первый вышел. (ИМХО, не очень честно… ) (Last-In-First-Out)
— SIRO. Ну, тут полный рандом. Service-In-Random-Out.
В случае «чистых» приоритетов таких вопросов не возникает, ясное дело.

А что же там с многопроцессорными системами?

Ведь я обещала поделиться своими мыслями на этот счет. Ну, давайте представим, что касс (процессоров) несколько. И тут те же принципы, только либо несколько очередей, и процессы попадают в рандомном или не очень порядке в очередь (что мне кажется не очень логичным, ну, например, хотя бы потому, что на новых процессорах по прежнему работают «однопроцессорные» системы). Либо так же очередь (пул, из которого берутся процессы) — одна, а обрабатывают их несколько касс. Но это исключительно мысли автора, не более того.

Может возникнуть вполне резонный вопрос.

А в чем же все-таки отличие процесса от потока?

А все просто. В начале статьи вскользь упоминалось, что программе для выполнения необходимы ресурсы и процессорное время. Так вот, система «воспринимает» процесс как заявку на любые виды ресурсов, кроме процессорного времени. Заявка на процессорное время — это поток. Именно процессорное время распределяется между потоками. Таким образом, процесс состоит из нескольких потоков. Раньше, конечно, это все было единое целое. И процесс, и поток, и все в одном, и вообще, «зачем платить больше?». Как оказалось, в данном случае мы, скорее, «платим меньше». Когда потоков несколько.

Для того, чтобы процессы не могли вмешиваться в распределение ресурсов, система их «изолирует». Предоставляет каждому из них своё виртуальное адресное пространство. Так что ни один процесс не может получить прямого доступа к командам и данным другого процесса.

При необходимости взаимодействия процессы обращаются к ОС, в буквальном смысле, как к посреднику. А она уже им помогает, выдаёт средства связи.

А вот между потоками одного и того же процесса нет полной защиты. Потому что это не только невозможно, но и никому не нужно. Чтобы обмениваться данными потокам вовсе не обязательно обращаться к ОС. Они используют общую память. Один записывает данные, другой читает. И все хорошо. Кроме того, потоки разных процессов по-прежнему хорошо защищены друг от друга.

Мультипрограммирование более эффективно на уровне потоков, а не процессов. Каждый поток имеет свой счетчик команд и стек. Задача, оформленная в виде нескольких потоков может быть выполнена быстрее за счет параллельного (или псевдопараллельного в однопроцессорной системе) выполнения её частей.

Очевидные выводы

Процесс — это заявка на потребление всех ресурсов, кроме процессорного времени. Процессы изолированы друг от друга, и включает в себя потоки. Собственно, потоки — это заявки на потребление этого самого процессорного времени.

Наибольший эффект от введения многопоточной обработки достигается в мультипроцессорных системах, в которых потоки (даже в рамках одного процесса) могут выполняться действительно параллельно, а не псевдо.

Ко всему прочему, был продемонстрировано на примере непосредственно концепт работы системы [массового обслуживания] как таковой.

Я немного «смахлевала» в начале и в середине статье, рассказывая по поводу процессорного времени для «процесса» как такового. Но не сильно, и, я надеюсь, Вы меня простите за эту вынужденную неточность.

Источник

Национальная библиотека им. Н. Э. Баумана
Bauman National Library

Персональные инструменты

Многозадачность (Операционные Системы)

Многозада́чность – понятие из теории операционных систем, под которым подразумевается обеспечение возможности параллельной (или псевдопараллельной) обработки нескольких процессов. Однако, идеальная многозадачность ОС возможна только в распределённых вычислительных системах.

Другими словами, многозадачностью можно назвать способ исполнения нескольких задач в один промежуток времени. При этом задачи распределяют между собой общие ресурсы (resources sharing), а также выполняют планирование (scheduling) задачи в очереди исполнения.

Сущусвуют однозадачные системы, которые не обладают свойством многозадачности, т.е. в такой ОС задачи исполняются последовательно. [Источник 1]

Содержание

Свойства многозадачной среды

Примитивные многозадачные среды обеспечивают чистое «разделение ресурсов», когда за каждой задачей закрепляется определённый участок памяти, и задача активизируется в строго определённые интервалы времени.

Более развитые многозадачные системы проводят распределение ресурсов динамически, когда задача стартует в памяти или покидает память в зависимости от её приоритета и от стратегии системы. Такая многозадачная среда обладает следующими особенностями:

Трудности реализации многозадачной среды

Основной трудностью реализации многозадачной среды является её надёжность, выраженная в защите памяти, обработке сбоев и прерываний, предохранении от зависаний и тупиковых ситуаций.

Кроме надёжности, многозадачная среда должна быть эффективной. Затраты ресурсов на её поддержание не должны: мешать процессам проходить, замедлять их работу, резко ограничивать память. [Источник 1]

История многозадачных операционных систем

Поначалу реализация многозадачных операционных систем представляла собой серьёзную техническую трудность, отчего внедрение многозадачных систем затягивалось, а пользователи долгое время после внедрения предпочитали однозадачные.

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

Впервые многозадачность операционной системы была реализована в ходе разработки операционной системы Multics (1964 год). Одной из первых многозадачных систем была OS/360 (1966), используемая для компьютеров фирмы IBM и их советских аналогов ЕС ЭВМ. Разработки системы были сильно затянуты, и на начальное время фирма IBM выдвинула однозадачный DOS, чтобы удовлетворить заказчиков до полной сдачи OS/360 в эксплуатацию. Система подвергалась критике по причине малой надёжности и трудности эксплуатации.

В 1969 году на основе Multics была разработана система UNIX с достаточно аккуратным алгоритмическим решением проблемы многозадачности. В настоящее время на базе созданы десятки операционных систем.

На компьютерах PDP-11 и их советских аналогах СМ-4 использовалась многозадачная система RSX-11 (советский аналог — ОСРВ СМ ЭВМ), и система распределения времени TSX-PLUS, обеспечивающая ограниченные возможности многозадачности и многопользовательский режим разделения времени, эмулируя для каждого пользователя однозадачную RT-11(советский аналог — РАФОС). Последнее решение было весьма популярно из-за низкой эффективности и надёжности полноценной многозадачной системы.

Аккуратным решением оказалась операционная система VMS, разработанная первоначально для компьютеров VAX (советский аналог — СМ-1700) как развитие RSX-11.

Первый в мире мультимедийный персональный компьютер Amiga 1000 (1984 год) изначально проектировался с расчётом на полную аппаратную поддержку вытесняющей многозадачности реального времени в ОС AmigaOS. В данном случае разработка аппаратной и программной части велась параллельно, это привело к тому, что по показателю квантования планировщика многозадачности (1/50 секунды на переключение контекста) AmigaOS долгое время оставалась непревзойдённой на персональных компьютерах.

Многозадачность обеспечивала также фирма Microsoft в операционных системах Windows. При этом Microsoft выбрала две линии разработок — на базе приобретённой ею Windows 0.9, которая после долгой доработки системы, изначально обладавшей кооперативной многозадачностью, аналогичной Mac OS, вылилась в линейку Windows 3.x, и на основе идей, заложенных в VMS, которые привели к созданию операционных систем Windows NT. Использование опыта VMS обеспечило системам существенно более высокую производительность и надёжность. По времени переключения контекста многозадачности (квантование) только эти операционные системы могут быть сравнимы с AmigaOS и UNIX(а также его потомками, такими, как ядро Linux).

Классификация

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

Процессная многозадачность.

Здесь программа — наименьший элемент управляемого кода, которым может управлять планировщик операционной системы. Известна большинству пользователей (одновременная работа в текстовом редакторе и прослушивание музыки). Многозадачная система позволяет двум или более программам выполняться одновременно.

Процесс — это понятие, относящееся к операционной системе. Каждый раз при запуске приложения создается и запускается новый процесс. С каждым процессом связаны следующие ресурсы, как:

Поточная многозадачность.

Многопоточность — специализированная форма многозадачности. Наименьший элемент управляемого кода — поток. Многопотоковая (multi-threaded) система предоставляет возможность одновременного выполнения одной программой 2 и более задач (потоков). Поток (thread) — это основной элемент системы, которому ОС выделяет машинное время. Поток может выполнять какую-то часть общего кода процесса, в том числе и ту часть, которая в это время уже выполняется другим потоком.

По способу организации времени выполнения каждого процесса

Параллельная многозадачность

Рисунок 1 – Propeller Parallax

Альтернативой параллельной многозадачности является применение псевдопараллельной многозадачности или совокупности параллельной и псевдопараллельной многозадачности при наличии нескольких процессорных ядер.

Типы псевдопараллельной многозадачности

Невытесняющая многозадачность

16-и разрядная Windows уже стала поддерживать и вытесняющую многозадачность (non-preemptive multitasking). Такой тип многозадачности стал возможен благодаря основанной на сообщениях архитектуре Windows.Windows – программа может находиться в памяти и не выполняться до тех пор, пока не получила сообщение. Ранее, эти сообщения часто являлись прямым или косвенным результатом ввода информации пользователем с клавиатуры или мыши. Сейчас, механизм посылки сообщений широко используется и для обмена данными, инициации какого-либо действия приложения и т.п.

При всем при этом, Windows использовала вытесняющую многозадачность для выполнения DOS – программ, а также позволяла некоторым программам, например, для целей мультимедиа, получать аппаратные прерывания от таймера.

Существенным ограничением такого подхода является то, что время, затрачиваемое программой на обработку сообщения может быть очень большим, а управление операционной системе передается только после обработки сообщения.

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

Первые операционные системы, реализованные на персональных компьютерах, сильно уступали в концептуальном плане и по своим реальным возможностям системам с разделением времени, давно реализованным в mainframe- компьютерах. В Win 16, например, тоже существует понятие многозадачности. Реализовано оно следующим образом: обработав очередное сообщение, приложение передает управление операционной системе, которая может передать управление другому приложению. Такой вид многозадачности, при котором операционная система передает управление от одного приложения другому не в любой момент времени, а только когда текущее приложение отдает управление системе, получил, как было упомянуто, название кооперативной многозадачности (cooperative multi-tasking).

Вытесняющая, или приоритетная, многозадачность (режим реального времени)

Схема обработки прерывания следующая:

Прерывания с более высоким приоритетом, в свою очередь, могут прервать обработку текущего прерывания и т.д.

Реализация вытесняющей многозадачности в Windows 2000 дает не только возможность плавного переключения задач, но и устойчивость среды к зависаниям, так как ни одно приложение не может получить неограниченные права на процессорное время и другие ресурсы. Так система создает эффект одновременного выполнения нескольких приложений. Если компьютер имеет несколько процессоров, то системы Windows NT/2000 могут действительно совмещать выполнение нескольких приложений. Если процессор один, то совмещение остается иллюзией. Когда заканчивается квант времени, отведенный текущей программе, система ее прерывает, сохраняет контекст и отдает управление другой программе, которая ждет своей очереди. Величина кванта времени (time slice) зависит от ОС и типа процессора, в Windows NT она в среднем равна 20 мс. Следует отметить, что добиться действительно одновременного выполнения потоков можно только на машине с несколькими процессорами и только под управлением Windows NT/2000, ядра которых поддерживают распределение потоков между процессорами и процессорного времени между потоками на каждом процессоре. Windows 95 работает только с одним процессором. Даже если у компьютера несколько процессоров, под управлением Windows 95 задействован лишь один из них, а остальные простаивают. [Источник 3]

Рисунок 2 – Переключение потоков

Диспетчеризация

Эффективность многозадачной системы во многом зависит от способа диспетчеризации задач на исполнение.

Состояние задачи

Для понимания диспетчеризации важным является понятие состояния задачи. Основные состояния задач такие:

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

В отличие от первых двух, состояние блокировки, вообще говоря не является обязательным.

Стратегии диспетчеризации

Известно несколько основных стратегий диспетчеризации:

Программная реализация многозадачности

Когда пользователь запускает программу, Windows создает в памяти компьютера экземпляр программы, называемый процессом. Процесс не является точной копией *.ехе – файла, как это было, например в операционной системе DOS. Процесс содержит в себе копию *.ехе – файла, а также некоторую другую информацию о функционировании данного приложения. В этой дополнительной информации хранятся, например, границы выделенной приложению памяти, что помогает отслеживать корректность обращения к оперативной памяти со стороны приложения. Так как Windows поддерживает механизм виртуальной памяти, то среди этой информации находятся сведения о расположении сегментов программы. Здесь же содержится командная строка, формируемая при запуске программы.

Запустить процесс можно как при помощи командной строки системного меню Windows, при помощи программы Проводника, так и программно, из другого приложения. Это можно выполнить при помощи функций API :

Для 16-битных приложений используется функция WinExec :

Первый параметр является командной строкой, в которой указывается имя файла и параметры, указываемые после имени загружаемого файла.

После запуска, программа начинает параллельную работу относительно приложения-родителя и ее выполнение не зависит от других приложений, если, конечно, зависимость не предусмотрена самой природой приложений.

В среде Windows 32 следует использовать другой способ порождения процессов:

Первый параметр является указателем на имя запускаемого файла. Имя может содержать полный путь к файлу (диск:\каталог\…\файл). Если имя не содержит пути, то операционная система ищет файл в текущем каталоге, затем в системных каталогах и в каталогах, указанных в разделе PATH при загрузке системы.

Второй параметр указывает на командную строку.

Третий и четвертый параметры определяют, может ли возвращаемый указатель процесса наследоваться дочерними процессами и потоками.

bInheritHandles и dwCreationFlags содержит дополнительные флаги управления созданием и приоритетом процесса.

lpEnvironment содержит указатель на буфер памяти, в котором будет создаваться служебная информация по процессу. Если равен NULL, то операционная система сама отводит место в памяти под эту информацию.

lpCurrentDirectory указатель на строку, содержащую путь к каталогу, который будет использоваться запускаемым процессом как текущий. Если значение поля равно, то текущей директорией будет считаться каталог, являющийся текущим для процесса-родителя.

lpProcessInformation указатель на структуру, заполняемую после создания нового процесса. Структура содержит информацию о созданном процессе.

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

Непосредственное использование системного таймера для указание процедуры, вызываемой периодически. Данный способ был рассмотрен в лекции «Использование Таймера». Это типичный представитель вытесняющей многозадачности. К достоинствам этого способа можно отнести то, что программа может устанавливать и изменять период вызова функции.

Использование системного таймера для организации посылки синхронных сообщений выбранному окну (порядок организации описан в лекции «Использование Таймера»). С помощью данного способа реализуется невытесняющая многозадачность. Достоинство – изменяемая периодичность посылки сообщений. Недостаток – природа синхронных сообщений не гарантирует четкое выполнение периода прихода сообщений от таймера.

Создание потоков. Данный способ подразумевает определение некоторой процедуры потока, которая запускается параллельно основному процессу приложения. Момент окончания выполнения потока контролирует сама поточная процедура.

Первый параметр определяет атрибуты безопасности для запускаемого потока. Если он равен NULL, то данный поток не может использоваться дочерними процессами.

Четвертый параметр определяет дополнительные флаги создания потока. Если этот параметр равен нулю, то поток создастся немедленно.

Последний параметр является адресом переменной, в которую возвращается идентификатор потока.

Использование функции Sleep

Итак, поток – это часть программы, запускаемая параллельно другим задачам процесса. Поток сам определяет как долго ему находится в памяти и какие действия надо совершать. Если поток должен периодически совершать одни и те же действия (например, обновлять экран или проверять почту), то самым естественным способом сделать это является организация бесконечного цикла (подобного циклу обработки сообщений). Однако, в этом случае не определено время цикличности, т.к. временные периоды выполнения потока определены операционной системой. Кроме того, как только одна итерация цикла заканчивается, начинается другая. Как же вызвать приостановку выполнения потока? Для этих целей существует функция Sleep, которая в качестве единственного параметра имеет время, задаваемое в миллисекундах. Функция не осуществляет возврата до тех пор, пока не истечет указанное время. При этом другие потоки и процессы работают в обычных режимах. Если параметр этой функции равен нулю, то операционная система просто лишает текущий поток оставшегося кванта времени.

Следует отметить, что данная функция не освобождает полностью процессор от исполнения потока. Действительно, процессор периодически должен проверять истекло ли время, заданное в функции. То есть, речь идет не о приостановке периодического выполнения потока, а лишь о задержке выполнения алгоритма потока на одной его команде (Sleep). [Источник 4]

Критические разделы

В многопоточной среде часто возникают проблемы, связанные с использованием параллельно исполняемыми потоками одних и тех же данных или устройств. Например, один из потоков, получает данные извне и помещает их в некоторый буфер памяти компьютера; Другой поток выбирает эти данные из буфера и отображает их на экран. Теперь представьте, что первый поток занес изменил только половину данных в буфере, операционная система переключилась на выполнение второго потока, и второй поток вывел на экран половину новых и половину старых данных.

В других случаях одновременное обращение к памяти может привести к неправильной работе программ, зависанию программы, потере данных и т.п.

Один из путей устранения конфликта состоит в том, что программист может определить участок потока, который должен быть выполнен без прерывания, т.е. пока участок потока не будет выполнен до конца, никакой из потоков данного процесса не будет выполняться.

Данный участок потока называется критическим разделом. Существует четыре функции работы с критическим разделом. Чтобы их использовать необходимо определеить объект типа критический раздел:

Объект типа критический раздел сначала должен быть инициализирован одним из потоков программы с помощью функции:

Эта функция создает критический раздел с именем cs.После инициализации объекта «критический раздел» поток входит в критический раздел, вызывая функцию:

В этот момент поток становиться владельцем объекта. Два различных потока не могут быть владельцами одного объекта одновременно. Следовательно, если один поток вошел в критический раздел, то следующий поток, вызывая функцию EnterCriticalSection(&cs) ; с тем же самым объектом, будет задержан внутри функции. Возврат из функции произойдет только тогда, когда первый поток покинет критический раздел, вызвав функцию:

Когда критический раздел больше не нужен вашей программе, его можно удалить с помощью функции:

Это приведет к освобождению всех ресурсов системы, задействованных для поддержки объекта критический раздел.

Программа может создавать несколько критических разделов. Существенное ограничение при использовании критических разделов состоит в том, что таким образом можно синхронизировать только потоки одного процесса и нельзя осуществить синхронизацию процессов (действительно, ведь переменная cs объявлена в процессе и не видна из других процессов). [Источник 4]

Использование событий

Альтернативным вариантом синхронизации является использование событий. Объект событие может быть либо свободным (signaled) или установленным (set), либо занятым (non-signaled) или сброшенным (reset). Вы можете создать объект «событие» с помощью функции:

Параметр fInitial устанавливается в TRUE, если вы хотите, чтобы объект Событие был изначально свободным, или в FALSE, чтобы он был занятым.

Параметр psz Name определяет имя события. По этому имени разные процессы могут использовать одно событие.

Для того, чтобы сделать свободным существующий объект Событие, надо вызвать функцию:

Чтобы сделать объект Событие занятым, вызывается функция:

Для синхронизации используется функция:

где второй параметр имеет значение INFINITE. Возврат из функции происходит немедленно, если объект событие в настоящее время свободен. В противном случае поток будет приостановлен в функции до тех пор, пока событие не станет свободным. Вы можете установить значение тайм-аута во втором параметре, задав его величину в миллисекундах. Тогда возврат из функции произойдет, когда объект Событие станет свободным или истечет тайм-аут.

Проблемные ситуации в многозадачных системах

Рисунок 3 – Взаимосвязь потоков и процессов

Голодание (starvation)

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

Негативный эффект заключается в том, что возникает задержка времени от пробуждения потока до исполнения им следующей важной операции, что задерживает исполнение этой операции, а следом за ней и работу многих других компонентов.

Голодание создаёт узкое место в системе и не дает выжать из неё максимальную производительность, ограничиваемую только аппаратно обусловленными узкими местами.

Любое голодание вне 100 % загрузки процессора может быть устранено повышением приоритета голодающей нити, возможно — временным.

Как правило, для предотвращения голодания ОС автоматически вызывает на исполнение готовые к нему низкоприоритетные потоки даже при наличии высокоприоритетных, при условии, что поток не исполнялся в течение долгого времени (

10 секунд). Визуально эта картина хорошо знакома большинству пользователей Windows — если в одной из программ поток зациклился до бесконечности, то переднее окно работает нормально, несмотря на это — потоку, связанному с передним окном, Windows повышает приоритет. Остальные же окна перерисовываются с большими задержками, по порции в секунду, ибо их отрисовка в данной ситуации работает только за счет механизма предотвращения голодания (иначе бы голодала вечно).

Гонка (race condition)

Недетерминированный порядок исполнения двух потоков кода, обрабатывающими одни и те же данные, исполняемыми в двух различных потоках (задачах). Приводит к зависимости порядка и правильности исполнения от случайных факторов.

Устраняется добавлением необходимых блокировок и примитивов синхронизации. Обычно является легко устраняемым дефектом (забытая блокировка).

Инверсия приоритета

Поток L имеет низкий приоритет, поток M — средний, поток H — высокий. Поток L захватывает mutex, и, выполняясь с удержанием mutex’а, прерывается потоком M, который пробудился по какой-то причине, и имеет более высокий приоритет. Поток H пытается захватить mutex.

В полученной ситуации поток H ожидает завершения текущей работы потоком M, ибо, пока поток M исполняется, низкоприоритетный поток L не получает управления и не может освободить mutex.

Устраняется повышением приоритета всех нитей, захватывающих данный mutex, до одного и того же высокого значения на период удержания mutexa. Некоторые реализации mutex’ов делают это автоматически. [Источник 4]

Процессы в Windows и потоковая многозадачность

Рисунок 4 – Пример работы планировщика

Планировщик может быть очень простым, обеспечивающим выполнение каждого из процессов одинаковое количество миллисекунд, а может работать с учетом различных уровней приоритета приложений, вытесняя низко­приоритетные приложения. Windows при запуске приложения и планирует его работу, и со стороны пользователя для этого не требуется никаких специальных действий.Рассмотреть наглядно простейший пример переключения между задачами можно на рисунке 4.

Многозадачность в Linux

К каждому процессу в системе привязаны идентификатор процесса PID (Process IDentifier) и идентификатор родительского процесса PPID (Parent Process IDentifier). Для каждого процесса PID является уникальным (в конкретный момент времени), а PPID равен идентификатору процесса-родителя.

Использование getpid() и getppid()

Процесс может узнать свой идентификатор (PID), а также родительский идентификатор (PPID) при помощи системных вызовов getpid() и getppid().

Системные вызовы getpid() и getppid() имеют следующие прототипы: pid_t getpid (void) ; pid_t getppid (void) ;

Проверим теперь, как работает эта программа. Для этого откомпилируем и запустим ее:

Источник