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

BOOL PostThreadMessage(dwThreadID, uMsg, wParam, lParam);

которая посылает сообщение конкретному потоку. При этом в очередь соответствующего потока помещается сообщение, имеющее нулевой хендл окна-получателя. Идентификатор потока dwThreadID можно получить посредством функций:

DWORD GetWindowThreadProcessId(hWnd, lpdwProcessID);

DWORD GetCurrentThreadId(void);

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

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

Однако в жизни ситуация существенно усложняется: часто поток, обрабатывающий переданное сообщение, передает пославшему потоку какое-либо «встречное» сообщение. Так, например, при начале DDE-разговора DDE-клиент передает с помощью функции SendMessage широковещательное сообщение WM_DDE_INITIATE, а DDE-сервер отвечает на это сообщение передачей сообщения WM_DDE_ACK, если он поддерживает требуемый DDE-разговор. То есть обработчик сообщения WM_DDE_INITIATE сервера передает с помощью той-же функции SendMessage сообщение WM_DDE_ACK окну клиента, которое в данный момент ждет конца обработки переданного им сообщения WM_DDE_INITIATE В случае 16ти битовой платформы Windows таких проблем не возникает, так как использование функции SendMessage подобно простому вызову оконной процедуры.. При этом было бы возможным зависание обеих потоков, так как поток клиента остановлен до конца обработки переданного им WM_DDE_INITIATE, а поток сервера будет ждать, пока остановленный поток клиента не ответит на встречное сообщение WM_DDE_ACK, которое он передает в качестве подтверждения.

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

Осторожно! Зависание потоков при обмене сообщениями все-таки возможно. Такая ситуация легко может случиться при использовании MDI: в Win32 для каждого открытого дочернего MDI-окна автоматически создается свой собственный поток. В этом случае при использовании функции SetFocus для передачи фокуса от одного дочернего MDI-окна другому дочернему MDI-окну (естественно принадлежащему другому потоку) происходит обмен сообщениями WM_SETFOCUS и WM_KILLFOCUS, что приводит к остановке обеих потоков. Эта особенность платформы официально описана Microsoft.

Кроме того возможно зависание потока, передавшего сообщение, если поток-получатель завис сам или занят очень продолжительными операциями. Так как продолжительная остановка передающего сообщение потока может быть нежелательна, то в Win32 API описаны специальные функции для работы с межпотоковыми сообщениями: SendMessageTimeout, SendMessageCallback, SendNotifyMessage и ReplyMessage.

Внимание! Функции SendMessageTimeout, SendMessageCallback и SendNotifyMessage не реализованы для платформы Win32s а, кроме того, в документации (правда не всегда) встречается странное упоминание о том, что в случае Windows-95 параметр wParam является 16ти битовым (!), что может существенно ограничить применение этих функций для передачи многих сообщений.

LRESULT SendMessageTimeout(

hWnd, uMsg, wParam, lParam, fuFlags, uTimeout, lpdwResult);

Дополнительные параметры этой функции: lpdwResult -- указывает переменную, в которую будет помещен результат обработки сообщения, uTimeout -- максимальное время, в миллисекундах, в течении которого надо ожидать результата, а fuFlags -- определяет, как функция будет ожидать ответа:

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

флаг SMTO_BLOCK исключает обработку «встречных» сообщений во время ожидания ответа. С этим флагом надо быть очень осторожным!

флаг SMTO_NORMAL используется тогда, когда ни SMTO_BLOCK ни SMTO_ABOPRTIFHUNG не указаны.

Возвращаемый функцией результат равен TRUE, если сообщение обработано или FALSE, если отведенное для ожидания время истекло или поток-получатель завис.

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

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

BOOL SendMessageCallback(hWnd, uMsg, wParam, lParam, lpfnResultCallback, dwData);

void CALLBACK ResultCallback(hWnd, uMsg, dwData, lResult) {...}

Параметр lpfnResultCallback является указателем на функцию-обработчик результата, а dwData -- некоторые дополнительные данные, которые вы хотите передать в вашу функцию-обработчик. Прототип этой функции приведен в следующей строке.

Уточнение: реально функция-обработчик результата будет вызвана не немедленно после обработки сообщения получателем, а результат обработки будет помещен в очередь обработанных сообщений, откуда он будет извлечен тогда, когда поток, передавший сообщение, обратиться к очереди сообщений для получения следующего (то есть при вызове GetMessage, PeekMessage, WaitMessage или одну из функций SendMessage...).

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

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

Отдельно стоит рассмотреть вопросы оптимизации обработки межпотоковых сообщений. Дело в том, что Windows NT может работать на многопроцессорных системах, реально выполняя несколько потоков в одно и то же время. В этом случае может быть целесообразно сократить время, в течении которого один поток просто ожидает результат обработки другого потока. Для этого предназначены две дополнительные функции ReplyMessage и SendNotifyMessage.

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

Функция SendNotifyMessage появилась на свет в связи с тем, что многие сообщения являются просто информационными. То есть они сообщают окну, что с ним сделано то-то и то-то, но результат обработки этого сообщения не нужен. Часто такие сообщения должны передаваться в синхронном режиме, например сообщение WM_DESTROY должно быть обработано во время выполнения функции DestroyWindow и до обработки сообщения WM_NCDESTROY, но то как оно будет обработано и каков результат его обработки -- не важно. В качестве обратного примера можно привести обработку сообщения WM_CREATE, так как результат обработки нужен для дальнейшего создания окна или отказа от его создания.

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

Подробнее о циклах обработки сообщений

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

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

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

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

При рассмотрении двух последних задач следует иметь в виду, что аналогичного эффекта можно добиться применением многопотоковых приложений. Более того, во многих случаях многопотоковый вариант оказывается предпочтительным. При принятии решения необходимо учитывать специфику разрабатываемого приложения и его область применения. Если отказ от устаревшей 16ти разрядной платформы Windows 3.x не вызывает возражений, а также речь идет о разработке нового приложения, а не переносе старого на новую платформу, то стоит серьезно проработать вопрос с реализацией многопотокового приложения.

Дополнительная обработка сообщений

Первая задача -- дополнительная обработка сообщений -- обычно сводится к выполнению дополнительных действий после извлечения сообщения из очереди и трансляцией этого сообщения. Для применения акселераторов обычно используют функцию TranslateAccelerator или TranslateMDISysAccel, для немодальных диалогов -- IsDialogMessage. Часто функции, выполнившие специфичную трансляцию сообщения, заодно передают их оконной процедуре, так что последующая трансляция и вызов DispatchMessage становятся не нужны. Например:

HWND hwndDlg = ...; // хендл окна немодального диалога

MSG msg;

while (GetMessage(&msg, NULL, NULL, NULL)) {

if (!IsWindow(hwndDlg) || !IsDialogMessage(hwndDlg, &msg)) {

TranslateMessage(&msg);

DispatchMessage(&msg);}}

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

Продолжительные операции

Вторая задача -- дать возможность нормальной работы интерфейса при выполнении продолжительных операций. Эта задача обычно решается путем встраивания вспомогательных циклов обработки сообщений в процессе выполнения продолжительных операций. Единственное, что при этом требуется -- что бы цикл завершался не по получению WM_QUIT, а по завершению обработки последнего сообщения в очереди, что бы приложение могло продолжить свою операцию. Для этого применяют функцию PeekMessage вместо GetMessage.

BOOL PeekMessage(lpMsg, hWnd, uFilterFirst, uFilterLast, fuRemove);

Эта функция осуществляет выборку сообщений из очереди, однако, если очередь пуста, функция PeekMessage просто возвращает FALSE, а не ждет поступления сообщения. Ее параметры аналогичны параметрам функции GetMessage, кроме дополнительного fuRemove. Этот параметр может быть комбинацией флага PM_NOYIELD и одного из флагов PM_REMOVE или PM_NOREMOVE.

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

Флаг PM_NOREMOVE явно указывает, что нужно только проверить наличие сообщений в очереди. Если сообщение есть, возвращается информация об этом сообщении (в структуре MSG), а сообщение остается в очереди. Флаг PM_REMOVE указывает на необходимость извлечения сообщений из очереди.

MSG msg;

// продолжительные операции (вычисления, печать ...)

while (PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE)) {

TranslateMessage(&msg);

DispatchMessage(&msg);}

// дальнейшие продолжительные операции

Такой цикл сначала обработает все сообщения, накопившиеся в очереди, а затем завершиться. При использовании таких циклов надо иметь в виду следующее:

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

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

MSG msg;

BOOL fStop = FALSE;

// продолжительные операции (вычисления, печать ...)

while (PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE)) {

if (msg.message == WM_QUIT) {

fStop = TRUE;

PostQuitMessage(msg.wParam); // так завершится цикл в WinMain

break; // а так -- этот}

MyTranslation(&msg); // будем считать, что сюда мы убрали всю

// трансляцию и вызов DispatchMessage}

if (!fStop) {

// дальнейшие продолжительные операции}

Обработка состояний простоя

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

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

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

Для реализации циклов с обработкой состояний простоя обычно применяют одну из двух функций: WaitMessage или GetMessage. Так как с WaitMessage мы еще не встречались, то сначала рассмотрим вариант с ней:

void WaitMessage(void);

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

for (;;) {

while (!PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE)) {

// ... выполнить операции во время простоя

WaitMessage(); // дождаться следующего сообщения}

if (msg.message == WM_QUIT) break; // прервать цикл по WM_QUIT

// нормальная обработка сообщения

TranslateMessage(&msg);

DispatchMessage(&msg);}

Такой цикл применяют обычно непосредственно в функции WinMain, вместо обычного. Надо отметить, что вызов одной функции GetMessage заменился на целый цикл из PeekMessage, необходимых операций и WaitMessage, а также проверку сообщения WM_QUIT. Причем вложенный цикл выполнятся однократно для каждого состояния простоя -- после возврата из функции WaitMessage в очереди будет присутствовать сообщение, PeekMessage вернет TRUE и вложенный цикл завершиться.

В принципе, вместо WaitMessage можно использовать GetMessage, примерно так:

for (;;) {

if (!PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE)) {

// ... выполнить операции во время простоя

if (!GetMessage(&msg, NULL, NULL, NULL)) break; // WM_QUIT (!)}

if (msg.message == WM_QUIT) break; // прервать цикл по WM_QUIT

...}

На чем остановиться?

При выборе между двумя разными способами организации продолжительных операций надо учитывать следующие соображения:

Вариант с обработкой состояний простоя существенно более трудоемкий, однако имеет определенные достоинства, связанные с тем, что может быть организовано выполнение нескольких видов продолжительных операций одновременно. Например, можно в состоянии простоя организовать одновременную печать документа на принтере, выполнение сложного математического расчета и, скажем, оптимизацию использования памяти задачей. До определенной степени такая организация приложения позволяет имитировать многопотоковые задачи в рамках одного потока. Это может быть оправдано при разработке приложений, работающих в среде Windows 3.x, не поддерживающей многопотоковые задачи. Для приложений Win32 API обычно проще воспользоваться дополнительными потоками.

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

Тщательный анализ создаваемого приложения часто приводит к упрощению поставленной задачи. Так, например, возможность организовать печать документа в фоновом режиме (при обработке состояний простоя или в отдельном потоке), невольно порождает желание воспользоваться этой возможностью “на всю катушку” -- разрешить одновременное редактирование документа, его печать, а также печать еще нескольких других документов разом. Дух захватывает от открывающихся возможностей.

Однако задумайтесь над такими вопросами:

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

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

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

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

Вопрос в другом -- как часто эти возможности будут использоваться и оправдают ли себя существенно возросшие требования к ресурсам, если эти возможности будут использоваться крайне редко?

Вот хороший пример -- редактор Notepad крайне прост, возможности его бедны, но он занимает мало ресурсов, быстро загружается сам и быстро считывает текстовые файлы. Редактор WinWord 97 обладает неизмеримо большими возможностями, но и неизмеримо большими требованиями к ресурсам системы, долго загружается сам и достаточно долго (по сравнению с Notepad) загружает редактируемый текст. Теперь вопрос -- если вам надо подправить пару строк в autoexec.bat, вы воспользуетесь редактором Notepad или WinWord?

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

Страницы: 1, 2