Марапулец Ю.В. Основы программирования в Win32API

Подождите немного. Документ загружается.

Функция возвращает TRUE в случае успеха и FALSE – в случае неудачи.

Рассмотрим более подробно аргументы функции:

lpApplicationName – указатель на строку, содержащую имя исполняемой

программы. Имя может быть полное. Если оно неполное, то поиск файла про-

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

NULL. В этом случае в качестве имени файла выступает первая, выделенная

пробелами лексема из строки lpCommandLine;

lpCommandLine – указатель командной строки. Если параметр lpApplica-

tionName имеет значение NULL, то имя исполняемого файла выделяется из

lpCommandLine, а поиск исполняемого файла производится в соответствии

с правилами, действующими в системе;

lpProcessAttributes – указатель на структуру, описывающую параметры

защиты процесса. Если параметру присвоено значение NULL, то устанавлива-

ются атрибуты «по умолчанию»;

lpThreadAttributes – указатель на структуру, описывающую параметры

защиты первичного потока. Если параметру присвоено значение NULL, то ус-

танавливаются атрибуты «по умолчанию»;

bInheritHandles – определяет, будет ли порожденный процесс наследовать

описатели (handles) объектов родительского процесса. Например, если родитель-

ский процесс AB, то он получил описатель процесса B и может им манипулиро-

вать. Если теперь он порождает процесс C с параметром bInheritHandles, равным

TRUE, то и процесс C сможет работать с описателем процесса B;

dwCreationFlags – определяет некоторые дополнительные условия созда-

ния процесса и его класс приоритета;

lpEnvironment – указатель на блок переменных среды порожденного про-

цесса. Если этот параметр равен NULL, то порожденный процесс наследует

среду родителя. Иначе он должен указывать на завершающийся нулем блок

строк, каждая из которых завершается нулем (аналогично DOS);

lpCurrentDirectory – указатель на строку, содержащую полное имя теку-

щего каталога порожденного процесса. Если этот параметр равен NULL, то

порожденный процесс наследует каталог родителя;

lpStartupInfo – указатель на структуру STARTUPINFO, которая определя-

ет параметры главного окна порожденного процесса;

lpProcessInformation – указатель на структуру, которая будет заполнена

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

Рассмотрим пример на использование данной функции:

// программа, запускающая Microsoft Word

#include <windows.h>

#include <conio.h>

#include <stdio.h>

main()

{

PROCESS_INFORMATION pi;

STARTUPINFO si ;

ZeroMemory( &si, sizeof(si));

si.cb = sizeof( si );

printf( "Press any key to start WinWord -- " );

getch();

CreateProcess(NULL, "WinWord", NULL, NULL, FALSE, 0,

NULL, NULL, &si, &pi);

return 0;

}…

Функция CreateThread() – создает новый поток в адресном пространстве

процесса. Формат функции:

HANDLE CreateThread

(LPSECURITY_ATTRIBUTES lpThreadAttributes,

// атрибуты защиты потока

DWORD dwStackSize, // размер стека в байтах

LPTHREAD_START_ROUTINE lpStartAddress,

//указатель на функцию потока

LPVOID lpParameter, // аргумент, передаваемый в функцию потока

BDWORD dwCreationFlags, // флаги управления созданием потока

LPDWORD lpThreadId,

// область памяти для возвращения идентификатора потока);…

Функция возвращает описатель порожденного потока. Параметры:

lpThreadAttributes – указатель на структуру, описывающую параметры

защиты потока; если параметру присвоено значение NULL, то устанавливают-

ся атрибуты «по умолчанию»;

dwStackSize – устанавливает размер стека, который отводится потоку; ес-

ли параметр равен нулю, то устанавливается стек, равный стеку первичного

потока;

lpStartAddress – адрес функции, которую будет исполнять поток; функция

имеет один 32-битный аргумент и возвращает 32-битное значение;

lpParameter – параметр, передаваемый в функцию, которую будет испол-

нять поток;

dwCreationFlags – дополнительный флаг, который управляет созданием

потока; если этот параметр равен CREATE_SUSPENDED, то поток после по-

рождения не запускается на исполнение до вызова функции ResumeThread;

lpThreadId – указатель на 32-битную переменную, которой будет при-

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

Рассмотрим пример на использование данной функции:

// программа, порождающая поток

#include < stdio.h >

#include < conio.h >

#include < windows.h >

DWORD WINAPI Output(LPVOID Param)

{

while(TRUE)

{

printf(«A») ;

Sleep(100) ;

}

return(0) ;

}

main()

{

HANDLE hThread ;

DWORD ThreadId ;

hThread = CreateThread(NULL, 0, Output, NULL, 0, &ThreadId) ;

getch() ;

TerminateThread(hThread, 0) ;

return(0) ;

} …

2.3. Управление потоками и процессами

2.3.1. Изменение приоритета процесса

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

времени центрального процессора, раньше завершают свою работу и способны

быстрее реагировать на действия пользователя. Если всем потокам будет при-

своен одинаково высокий приоритет, ничего хорошего не выйдет. Дело

в том,

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

имеет значения, высокий или низкий), то программа-планировщик выделит им

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

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

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

равной степени применимо и к процессам. Старайтесь ограничивать приоритет

всех потоков и процессов низким или средним уровнем и присваивайте им вы-

сокий приоритет только по мере необходимости [2].

Приведенные ниже функции проверяют или изменяют базовый

приоритет потока:

BOOL SetThreadPriority

(HANDLE hThread // дескриптор потока

int iPriority); // новый уровень приоритета

int GetThreadPriority (HANDLE hThread);…

Функция SetThreadPriority() возвращает значение TRUE в случае успешно-

го завершения потока, а значение FALSE – и при возникновении ошибки. Функ-

ция GetThreadPriority() возвращает значение, определяющее приоритет.

Для обозначения возможных значений приоритета в обеих функциях ис-

пользуется набор констант:

THREAD_PRIORITY_LOWESTCor" – на два уровня ниже приоритета процесса;

THREAD_PRIORITY_BELOW_NORMAL – на один уровень ниже приоритета

процесса;

THREAD_PRIORITY_NORMAL

– Тот же уровень приоритета, что и у процесса;

THREAD_PRIORITY_ABOVE_NORMAL

– На один уровень выше приоритета

процесса;

THREAD_PRIORITY_HIGHEST

– На два уровня выше приоритета процесса;

THREAD_PRIORITY_TIME_CRITICAL

– Уровень 15 (для обычных пользова-

тельских процессов);

THREAD_PRIORITY_IDLE

– Уровень 1 (для обычных пользовательских про-

цессов).

2.3.2. Прерывание и возобновление выполнения потоков

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

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

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

ние. Остановку потока можно произвести, в частности, в том случае, если

пользователь прерывает выполнение определенной задачи. До тех пор, пока

задание не будет отменено, поток можно перевести в состояние ожидания. Ес-

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

той точки, где он был остановлен. Для приостановки и возобновления выпол-

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

DWORD SuspendThread (HANDLE hThread);

DWORD ResumeThread(HANDLE hThread).

Один и тот же поток можно последовательно остановить несколько раз,

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

SuspendThread() должна соответствовать ответная команда ResumeThread().

Система отсчитывает количество отмененных команд с помощью счетчика

прерываний. Каждая команда SuspendThread() инкрементирует значения счет-

чика, а каждая команда ResumeThread() декрементирует его. Обе функции воз-

вращают предыдущее значение счетчика в виде параметра типа DWORD. По-

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

значение 0.

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

зобновить свое выполнение. Однако он может на нужное время перенести себя

в режим ожидания. Функция Sleep() задерживает выполнения потока, удаляя

его из очереди программы-планировщика до тех пор, пока не пройдет задан-

ный интервал времени. Интерактивные потоки, которые выводят определен-

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

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

предпочтительнее задействования «пустого» цикла, поскольку в этом случае

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

Для осуществления паузы в течение заданного времени поток вызывает

следующие функции:

VOID Sleep (DWORD dwMilliseconds);

DWORD SleepEx(DWORD dwMilliseconds, // продолжительность паузы

BOOL bAlertable);…

Расширенная функция SleepEx() обычно работает совместно с функциями

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

или записи, не требуя их завершения. Эти операции выполняются в фоновом

режиме. По завершении операции система извещает об этом пользователя, об-

ращаясь к предусмотренной в программе процедуре обратного вызова. Фоно-

вый ввод/вывод (который иногда называют перекрывающимся вво-

дом/выводом) чаще всего применяется в интерактивных программах, которые

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

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

те или с сетевым диском.

Параметр bAlertable функции SleepEx() имеет тип Boolean. Если этот пара-

метр равен TRUE, система может преждевременно возобновить выполнение по-

тока при условии, что перекрывающаяся операция ввода/вывода завершилась до

истечения заданного времени ожидания. В случае досрочного прерывания функ-

ция SleepEx() возвращает значение WAIT_IO_COMPLETION,

по истечении ука-

занного времени – значение 0.

2.3.3. Получение информации о существующих потоках

По специальному запросу поток возвращает свои дескриптор и иденти-

фикатор. Указанные ниже функции позволяют получить информацию о теку-

щем потоке:

DWORD GetCurrentThreadId(VOID) ;

HANDLE GetCurrentThread(VOID);…

Результирующее значение функции GetCurrentThreadId() совпадает со

значением параметра lpIDThread после выполнения функции CreateThread() и

однозначно идентифицирует поток в системе. Хотя идентификатор потока ну-

жен лишь для незначительного количества функций Win32 API, он может ис-

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

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

тор защищает поток от уничтожения.

Дескриптор, полученный в результате выполнения функции GetCurrent-

Thread(), служит для тех же целей, что и дескриптор, возвращенный функцией

CreateThread(). Несмотря на то, что он может использоваться аналогично дру-

гим дескрипторам, на самом деле этот параметр является псевдодескриптором.

Псевдодескриптор – это специальная константа, которая всегда интерпретиру-

ется системой особым образом, подобно тому, как одиночная точка () в DOS

всегда указывает на текущий каталог, а параметр this в C++ определяет теку-

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

ния функции GetCurrentThread(), указывает на текущий поток. В отличие от

настоящих дескрипторов, псевдодескриптор не может передаваться другим

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

ходимо выполнить следующие действия:

HANDLE hThread;

hThread = DuplicateHandle(GetCurrentProcess(), // процесс-источник

GetCurrentThread(), // исходный дескриптор

GetCurrentProcess(), // целевой процесс

&hThread, // новый дублирующийся дескриптор

0, //привилегии доступа (подавляемые

// последним параметром)

FALSE, // дочерние объекты не унаследуют дескрип-

тор

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

копируются у исходного дескриптора);…

Хотя функция CloseHandle() не влияет на псевдодескрипторы, дескрип-

тор, созданный с помощью функции DuplicateHandle(), является настоящим и в

конце концов должен быть закрыт. Применение псевдодескрипторов значи-

тельно ускоряет работу функции GetCurrentThread(), поскольку в этом случае

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

вращает результат, не заботясь о мерах безопасности.

2.3.4. Прекращение выполнения потока

По аналогии с тем, как Windows-программа завершается по достижении

конца функции WinMain(), поток обычно прекращает свое существование при

достижении конца функции, в которой был начат. Когда он достигает конца

стартовой функции, система автоматически вызывает команду ExitThread(),

имеющую синтаксис:

VOID ExitThread(DWORD dwExitCode);…

Хотя операционная система вызывает функцию ExitThread() автоматиче-

ски, при необходимости досрочного завершения потока вы можете вызвать эту

функцию явным образом:

DWORD ThreadFunction(LPDWORD lpdwParam)

{

HANDLE hThread = CreateThread(< параметры >);

// далее следуют стандартные операции инициализации;

// проверка наличия ошибочных условий

if (< условие возникновения ошибки >)

{

ExitThread(ERROR_CODE); // прекратить работу потока

}

// ошибки нет, работа продолжается

return (SUCCESS_CODE); // эта строка программы заставляет систему

вызвать функцию ExitThread()

}…

Параметры ERROR_CODE

и SUCCESS_CODE определяются по вашему

усмотрению. В нашем простом примере поток нетрудно прервать с помощью

команды return:

if( < условие возникновения ошибки > )

{

return(ERROR_CODE); // прекратить работу потока

}…

В данном случае команда return приводит к тому же результату, что и

функция ExitThread(), так как при ее выполнении осуществляется неявный вызов

последней. Эта функция особенно полезна при необходимости прервать поток из

любой подпрограммы, вызываемой внутри функции типа ThreadFunction ().

Когда поток завершается с помощью оператора return, 32-разрядный код за-

вершения автоматически передается функции ExitThread(). После прекращения

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

веденной ниже:

// один поток вызывает эту функцию для получения

// кода завершения другого потока

BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpdwExitCode);…

Функция GetExitCodeThread() возвращает значение FALSE

в том случае, если

определить код завершения помешала ошибка.

Независимо от того, как – явно или неявно (в результате выполнения опера-

тора return) – вызывается функция ExitThread(), она удаляет поток из очереди про-

граммы-планировщика и уничтожает его стек. Однако сам объект при этом сохра-

няется. Поэтому даже после прекращения выполнения потока вы можете

запросить его код завершения. По возможности дескриптор потока следует закры-

вать явно (с помощью функций CloseHandle()), с тем чтобы поток не занимал лиш-

ний объем памяти. При закрытии последнего дескриптора система автоматически

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

если закрыты все его дескрипторы. В этом случае поток будет уничтожен сразу же

после завершения выполнения. Если по завершении процесса остаются незакры-

тые дескрипторы, система закрывает их автоматически и удаляет все «подвешен-

ные» объекты, которые не принадлежат ни одному процессу.

С помощью функции ExitThread() поток может остановить себя самостоя-

тельно в том месте программы, где это необходимо. Кроме того, один поток

способен по своему усмотрению мгновенно остановить другой поток:

// с помощью вызова этой функции один поток может остановить другой

BOOL TerminateThread ( HANDLE hThread, DWORD dwExitCode ).

Поток не в состоянии защитить себя от прерывания. Имея соответствующий

дескриптор, любой объект может мгновенно остановить поток вне зависимости

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

полный доступ к потоку). Если при вызове функции CreateThread() использовать

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

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

Функция TerminateThread() не уничтожает стек потока, а только возвращает

код его завершения. Функции ExitThread() и TerminateThread() переводят объект в

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

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

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

не будут закрыты все его дескрипторы.

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

2.4.1. Общие положения

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

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

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

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

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

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

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

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

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

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

С помощью одного набора обобщенных команд можно организовать ожидание

сигналов от процессов, семафоров, исключающих семафоров, событий и неко-

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

указанного объекта:

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

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

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

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

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

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

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

INFINITE.

Если объект уже доступен или если он подает сигнал в течение задан-

ного времени, функция WaitForSingleObject() возвращает значение 0 и выполнение

потока возобновляется. Но если заданный интервал времени прошел, а объект не

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

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

константу INFINITE.

Если по какой-либо причине объект никогда не подаст

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

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

друг от друга, возникнет тупиковая ситуация.

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

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

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

объектов, либо от всех объектов вместе. В программе, управляемой события-

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

DWORD WaitForMultipleObjects

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

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

BOOL bWaitAll, // TRUE – ожидание сигналов сразу от всех объектов;

// FALSE – ожидание сигнала от любого из объектов

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

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

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

bWaitAll имеет значение FALSE,

соответствующее ожиданию сигнала от любого

из указанных объектов, в случае успешного завершения функция WaitForMultip-

leObjects() возвращает код, который указывает, от какого из элементов массива

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-команды, позволяющие создавать и уничтожать эти объекты, захватывать

их и освобождать, а также получать их дескрипторы.

2.4.2. Семафоры и исключающие семафоры

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

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

екта (можно также указать его имя, но это необязательно) [2]:

HANDLE CreateMutext

(LPSECURITY_ATTRIBUTES lpsa,

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

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

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

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

HANDLE CreateSemaphore