Многозадачность Windows от NT до Vista

Московский  Авиационный Институт

      (Государственный технический университет) 
 
 
 
 
 

     Реферат по предмету ”Операционные системы”

     на  тему: ”Многозадачность Windows от NT до Vista” 
 
 
 
 

     Выполнила студентка гр.06-321

     Венгловская Е.Ю.

     Проверил 

     Терентьев М.Н. 
 
 
 
 
 
 
 
 
 

Москва 2010

     Содержание: 

1. Что такое  многозадачность?....................................................стр.3

 

2. Основные  принципы многозадачности в Windows………...стр.4

 
 

3. Синхронизация потоков……………………………………...стр.5

 

4. Windows NT как родоначальник многозадачности………...стр.10

 
 

5. NT и ее улучшенные версии…………………………………стр.11

 

     Windows 95……………………………………………………………….стр.11 

     Windows 98……………………………………………………………….стр.12 

     Windows 2000…………………………………………………………….стр.12 

     Windows XP………………………………………………………………стр.13 

     Windows Vista…………………………………………………………….стр.14 

6. Сходства  и различия Windows 9x и Windows NT (2000, XP)..стр.15

 

7. Заключение  ……………………………………………………стр.17

 
 

8. Список  литературы……………………………………………стр.18

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Что такое многозадачность? 

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

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

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

      В системах распределения времени  выполняемая задача нуждается  в  отступлении от центрального процессора, либо добровольно, либо по д воздействием внешнего фактора, такого как вмешательство аппаратного обеспечения. Системы распределения времени изобретены для того, чтобы позволить нескольким программам выполняться предположительно одновременно, совместно. Выражение «распределение времени» обычно использовалось для объявления компьютеров, которые разделены интерактивными пользователями на границах, таких как  IBM’s TSO и VM/CMS.

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

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

      Процесс необходим для реализации основных идей многозадачности. Наша задача, т.е задача пользователей, различать системные управляющие процессы, которые показывают работу операционной системы и те, которые занимаются распределением и управлением ресурсов, от всех остальных процессов. Процесс может находится в активном или пассивном состоянии. В активном состоянии процесс участвует в конкуренции использовать ресурсы системы. В пассивном же состоянии – он всего лишь известен системе, а в самой конкуренции он не принимает участия. В то же время, активный процесс может быть в следующих трех состояниях: выполнение, готовность к выполнению и блокирование (ожидание). Состояние выполнения состоит в том, что все требуемый ресурсы выделены и что только один процесс может находится в нем в определенный момент времени. Состояние готовности к выполнению означает, что процесс перейдет в состояние выполнения только после того, как ресурсы будут предоставлены. А состояние блокирования (ожидания) показывает, что операция ввода/вывода не завершилась и ресурсы не могут быть предоставлены.  

Основные  принципы многозадачности  в Windows 

      В Windows каждый поток имеет свое собственное адресное пространство, причем виртуальное. Процесс – статический объект, который сам по себе действие не совершает, хоть и состоит из кода, данных, синхронизирующих объектов, каналов и отрытых файлов.

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

      Основная  способность первичного потока –  это создание вторичных потоков.

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

      Для многих операционных систем многозадачность  превосходно отвечает требованиям, так как домашние компьютеры выполняют  маленькое количество хорошо протестированных программ. Window NT стала первой версий Microsoft Windows, которая навязывает преимущественную многозадачность, но он не появился на рынке для обычных пользователей до появления Windows XP

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

Windows NT использует вытесняющую многозадачность. Это означает, что операционная система строго контролирует, как выполняются все процессы. Для каждой из программ операционная система выделяет определенное количество процессорного времени и мы можем наблюдать переключение между запущенными на компьютере программами, производимое операционной системой. Мы имеем возможность обратиться к специальному системному вызову, с помощью которого мы как будто приостанавливаем (“усыпляем”) действие программы. Но если даже мы этого не сделаем, в последствии операционная система сделает это сама. Если одна из программ будет в подвешенном состоянии, то система не зависнет.

      Но  все выглядит не так уж и просто в  Windows NT. Давайте представим, что наш поток открыл файл и начал в него запись, но в этот же момент наша операционная система передала управление другому потоку. И представим. Что этот поток захочет открыть этот же файл. Что тогда произойдет? Возможно два исхода: первый - это сделать не получится и второй – наш второй поток откроет этот файл в режиме “for sharing”, т.е в режиме совместного доступа. Это нам совершенно не подходит. С этой же проблемой мы сможем столкнуться, если файл попытается открыть не другой поток нашей операционной системой, а поток, принадлежащий другому процессору. 
 
 
 
 
 
 

     Синхронизация потоков 

     При работе с потоками необходимо иметь  возможность координировать их дейст-

вия. Часто координация  действий подразумевает определенный порядок выполнения

операций. Кроме  функций, предназначенных для создания потоков и изменения их пла-

нового приоритета, Win32 API содержит функции, которые переводят  потоки в режим

ожидания сигналов от определенных объектов, например от файлов или процессов.

Кроме того, эти  функции обеспечивают поддержку  некоторых специальных объектов, в

частности семафоров  и исключающих семафоров.

     Лучше всего проиллюстрировать применение синхронизирующих объектов можно

на примере  функций, ожидающих сигнала от объекта. С помощью одного набора обоб-

щенных команд можно организовать ожидание сигналов от процессов, семафоров, ис-

ключающих семафоров, событий и некоторых других объектов. Следующая функция

ожидает поступления  сигнала от указанного объекта: 
 
 

     DWORD WaitForSingleObject( HANDLE hObject,           // объект, сигнал от

                                                                                              // которого ожидается

       DWORD dwMilliseconds );                                     // максимальное время ожидания 
 
 

     Функция WaitForSingleObject позволяет приостановить выполнение потока до тех

пор, пока не поступит сигнал от заданного объекта. Кроме  того, в этой команде указыва-

ется максимальное время ожидания. Чтобы обеспечить бесконечное ожидание, в качест-

ве временного интервала следует задать значение INFINITE. Если объект уже доступен

или если он подает сигнал в течение заданного времени, функция WaitForSingleObject

возвращает значение 0 и выполнение потока возобновляется. Но если заданный интер-

вал времени  прошел, а объект не подал сигнала, функция возвращает значение

WAIT_TIMEOUT.

     Для того чтобы заставить поток ожидать  сигналы сразу от нескольких объектов,

воспользуйтесь  функцией WaitForMultipleObjects. Функция возвратит  управление пото-

ку при поступлении  сигнала либо от одного из указанных  объектов, либо от всех объек-

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

     DWORD WaitForMultipleObjects(

         DWORD dwNumObjects,                      // количество ожидаемых объектов

         LPHANDLE lpHandles,                       // массив дескрипторов

         BOOL bWaitAll,                                 // TRUE - ожидание сигналов

                                                   // сразу от всех объектов;

                                                  // FALSE - ожидание сигнала от

                                                 // любого из объектов

      DWORD dwMilliseconds );                 // максимальный период ожидания 
 

Результирующее  значение WAIT_TIMEOUT, опять-таки, говорит  о том, что задан-

ный интервал времени  прошел, а сигнал от объектов не поступил. Если флаг bWaitAll

имеет значение FALSE, соответствующее ожиданию сигнала  от любого из указанных

объектов, в случае успешного завершения функция WaitForMultipleObjects возвращает

код, который  указывает, от какого из элементов массива lpHandles поступил сигнал.

(Первый элемент  массива соответствует значению 0, второй - значению 1 и т.д.). Если

флаг bWaitАll имеет  значение TRUE, функция не возвращает результат до тех пор, пока

не будут установлены  флаги всех объектов (т.е. пока не завершите выполнение всех по-

токов).

     Две  расширенные версии функций ожидания  содержат дополнительный флаг  ста-

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

периода ожидания были завершены асинхронные операции чтения или записи. Работу

этих функций  можно представить так, как будто  они просят "разбудить" их в  одном из

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

ный период времени  или если завершилось выполнение фоновой операции вво-

да/вывода. 
 

DWORD WaitForSingleObjectEx (

    HANDLE hObject,                              // объект, сигнал от которого ожидается

    DWORD dwMilliseconds,                                   // максимальное время ожидания

    BOOL bAlertable );                                 // TRUE - прекращение ожидания

                                                                     // при завершении операции ввода/вывода

DWORD WaitForMultipleObjectsEx(

    DWORD dwNumObjects,                         // количество ожидаемых объектов

    LPHANDLE lpHandles,                                            // массив дескрипторов

    BOOL bWaitAll,                                  // TRUE - ожидание сигналов

                                                                 // сразу от всех объектов;

                                                                 // FALSE - ожидание сигнала от

                                                                // любого из объектов

      DWORD dwMilliseconds,                                // максимальный период ожидания

      BOOL bAlertable );                                // TRUE - прекращение ожидания

                                                                     // при завершении операции ввода/вывода 
 
 

      При успешном выполнении функции  ожидания объект, сигнал от которого  ожи-

дался, обычно определенным образом изменяется. Например, если поток ожидал и по-

лучил сигнал от исключающего семафора, функция восстанавливает  несигнальное со-

стояние исключающего семафора, чтобы остальные потоки знали о том, что он занят.

Кроме того, функции  ожидания декрементируют значение счетчика семафора и сбрасы-

вают информацию о некоторых событиях.

      Функции ожидания не изменяют  состояния указанного объекта  до тех пор, пока не

поступит сигнал от одного или нескольких других объектов. В частности, поток не за-

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

ет сигналов от других объектов. Кроме того, в  течение времени ожидания исключающий

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

стояние ожидания.

      Конечно, ожидать поступления  сигнала от объекта можно лишь  в том случае, если

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

скольку для  работы с ними существуют параллельные API-команды, позволяющие соз-

давать и уничтожать эти объекты, захватывать их и  освобождать, а также получать их

дескрипторы.

      Функциям, создающим исключающие  семафоры и семафоры, нужно указать тре-

буемые привилегии доступа и начальные параметры  создаваемого объекта (можно также

указать его  имя, но это необязательно) [12]. 

HANDLE CreateMutex (

    LPSECURITY_ATTRIBUTES lpsa,      // необязательные атрибуты безопасности

    BOOL bInitialOwner                                       // TRUE - создатель хочет

                                                                            // завладеть полученным объектом

    LPTSTR lpszMutexName )                                            // имя объекта 

HANDLE CreateSemaphore(

    LPSECURITY_ATTRIBUTES lpsa,        //необязательные атрибуты безопасности

    LONG lInitialCount,                                  // исходное значение счетчика (обычно 0)

    LONG lMaxCount,                                         // максимальное значение

                                                                           // счетчика (ограничивает число потоков)

    LPTSTR lpszSemName );              // имя семафора (может иметь значение NULL) 

     Если  в качестве атрибута безопасности задано значение NULL, результирующий

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

цессами. Имена  объектов являются необязательными, однако они становятся полезными

в ситуации, когда  несколько процессов управляют одним и тем же объектом.

     Если  флагу bInitialOwner присвоить значение TRUE, поток сразу после создания

объекта завладеет  им. Созданный исключающий семафор  не станет подавать сигналы до

тех пор, пока поток  не освободит его.

     В  отличие от исключающего семафора, который может принадлежать только од-

ному потоку, неисключающий семафор остается в сигнальном состоянии до тех  пор, по-

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

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

      Пока семафор (или исключающий  семафор) существует, поток взаимодействует  с

ним посредством  операций захвата и освобождения. Для захвата любого объекта поток

вызывает функцию WaitForSingleObject (или одну из ее разновидностей). Завершив вы-

полнение задачи, которая синхронизировалась захваченным  объектом, поток освобож-

дает этот объект с помощью одной из следующих  функций: 
 
 

BOOL ReleaseMutex( HANDLE hMutex ) ; 

BOOL ReleaseSemaphore(

     HANDLE hSemaphore,

     LONG lRelease,        // величина, на которую

                                      // инкрементируется значение счетчика

                                      // при освобождении объекта (обычно 1)

      LPLONG lplPrevious );           // переменная, которой присваивается

                                                      // предыдущее значение счетчика 
 
 

     При  освобождении семафора: или исключающего  семафора значение счетчика за-

хватов инкрементируется. Значение счетчика, превышающее 0, воспринимается систе-

мой как сигнал объекта ожидающим его потокам.

     Освободить  исключающий семафор может только  тот поток, который завладел  им.

Однако любой  поток может вызвать функцию ReleaseSemaphore, которая инкрементиру-

ет значение счетчика захватов обычного семафора вплоть до его максимального значе-

ния. Изменение  значения счетчика дает возможность  в процессе выполнения программы

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

Обратите внимание, что функция CreateSemaphore позволяет при  создании нового сема-

фора присвоить  его счетчику значение, меньшее максимального. Например, при разра-

ботке нового семафора его счетчику можно задать начальное значение 0. Такой прием

позволит заблокировать  все потоки до тех пор, пока программа  не произведет инициали-

зацию, а затем  не увеличит значение счетчика с помощью  команды ReleaseSemaphore.

     Не  забывайте вовремя освобождать  синхронизирующие объекты. Не задав макси-

мального времени  ожидания и забыв освободить исключающий  семафор, вы заблоки-

руете все ожидающие  его потоки.

     Поток  может ожидать несколько сигналов  от одного и того же объекта,  не будучи

заблокированным, однако после завершения каждого из процессов ожидания необходи-

мо, выполнять  операцию освобождения. Это требование справедливо для семафоров,

исключающих семафоров  и критических разделов.

     Событие  представляет собой объект, который  создается программой при необхо-

димости информировать потоки о выполнении определенных действий. В простейшем

случае (ручной сброс) событие переключает свое состояние с помощью команд SetEvent

(сигнал включен)  и ResetEvent (сигнал выключен). Когда  сигнал включается, его полу-

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

выключается, все  такие потоки блокируются. В отличие  от семафоров и исключающих

семафоров, события  данного типа изменяют свое состояние  только при подаче соответ-

ствующей команды  каким-нибудь потоком.

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

только после  того, как программа обновит свое окно или пользователь введет опреде-

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

работы с событиями: 
 
 

HANDLE CreateEvent(

    LPSECURITY_ATTRIBUTES lpsa,                       // привилегии доступа

                                                                                     // (по умолчанию = NULL)

      BOOL bManualReset,                      // TRUE - событие должно быть

                                                               // сброшено вручную

      BOOL bInitialState,                                 // TRUE - создание события в

                                                                        // сигнальном состоянии

      LPTSTR lpszEventName );           //имя события (допускается

                                                            // значение NULL)

BOOL SetEvent ( HANDLE hEvent );

BOOL ResetEvent( HANDLE hEvent ); 
 
 

      При установке параметра bInitialState функция CreateEvent создает событие,  кото-

рое сразу же будет находиться в сигнальное состоянии. Функции SetEvent и ResetEvent в

случае успешного  завершения возвращают значение TRUE, при  возникновении ошибки

- значение FALSE.

      Параметр bManualReset функции CreateEvent позволяет  создать событие, сбрасы-

ваемое не вручную, а автоматически. Автоматически  сбрасываемое событие переходит  в

несигнальное  состояние сразу же после выполнения функции SetEvent. Для таких собы-

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

сом по каждому  сигналу событие освобождает  только один поток. Автоматически сбра-

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

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

нового набора данных основной поток устанавливает  событие, по которому освобожда-

ется один вспомогательный  поток. Остальные вспомогательные  потоки продолжают