Применение Windows API - А. Легалов
Шрифт:
Интервал:
Закладка:
~Thread() {
CloseHandle(_handle);
}
void Resume() {
ResumeThread(_handle);
}
void WaitForDeath() {
WaitForSingleObject(_handle, 2000);
}
private:
HANDLE _handle;
DWORD _tid; // thread id
};
Синхронизация — это то, что действительно делает многозадачный режим столь интенсивно используемым. Давайте, начнем со взаимных исключений. Класс Mutex — тонкая инкапсуляция API. Вы внедряете Mutexes (мутации) в ваш Активный Объект, а затем используете их через Блокировки. Блокировка (Lock) — умный объект, который создается на стеке. В результате чего, во время обслуживания, ваш объект защищен от любых других потоков. Класс Lock — одно из приложений методологии Управления ресурсами. Вы должны поместить Lock внутри всех методов вашего Активного Объекта, которые разделяют доступ к данным с другими потоками.
class Mutex {
friend class Lock;
public:
Mutex() {
InitializeCriticalSection(&_critSection);
}
~Mutex() {
DeleteCriticalSection(&_critSection);
}
private:
void Acquire() {
EnterCriticalSection(&_critSection);
}
void Release() {
LeaveCriticalSection(&_critSection);
}
CRITICAL_SECTION _critSection;
};
class Lock {
public:
// Acquire the state of the semaphore
Lock(Mutex& mutex) : _mutex(mutex) {
_mutex.Acquire();
}
// Release the state of the semaphore
~Lock() {
_mutex.Release();
}
private:
Mutex& _mutex;
};
Событие — это сигнальное устройство, которое потоки используют, чтобы связаться друг с другом. Вы внедряете Событие (Event) в ваш активный объект. Затем Вы переводите удерживаемый поток в состояние ожидания, пока некоторый другой поток не освободит его. Не забудьте однако, что, если ваш удерживаемй поток ожидает события, он не может быть завершен. Именно поэтому Вы должны вызывать Release из метода Flush.
class Event {
public:
Event() {
// start in non-signaled state (red light)
// auto reset after every Wait
_handle = CreateEvent(0, FALSE, FALSE, 0);
}
~Event() {
CloseHandle(_handle);
}
// put into signaled state
void Release() {
SetEvent(_handle);
}
void Wait() {
// Wait until event is in signaled (green) state
WaitForSingleObject(_handle, INFINITE);
}
operator HANDLE() { return _handle; }
private:
HANDLE _handle;
};
Чтобы увидеть, как эти классы могут быть использованы, я предлагаю небольшую подсказку. Вы можете перейти к странице, которая объясняет, как класс ActiveObject используется в Частотном анализаторе для асинхронной модификации дисплеев. Или, Вы можете изучить более простой пример Наблюдателя Папки, который спокойно ждет, отображая папки, и пробуждается только, когда присходит изменение ее содержимого.
Жаль, что я не могу сказать, что программирование потоков является простым. Однако, оно будет проще, если Вы станете использовать правильные примитивы. Это примитивы, которые я рекламировал: ActiveObject, Thread, Mutex, Lock и Event. Некоторые из них фактически доступны в MFC. К примеру, там есть блокирующий объект CLock (а может быть — это ЧАСЫ [CLock — игра слов]?) деструктор которого управляет, критической секцией (он немного менее удобен из-за «двухшаговой» конструкции: Вы должны создать его, а затем выбирать его в два отдельных шага — как будто бы вы захотели создать его, а затем передумать). Другое отличие: MFC предлагает только некоторую тонкую фанеру над API и ничего нового.
Вы можете также распознать в некоторых из механизмов, которые я представил здесь, аналоги из языка программирования Java. Конечно, когда Вы имеете свободу проектирования многозадачного режима в языке, Вы можете позволять себе быть изящными. Их версия ActiveObject называется Runnable, и она имеет метод run. Каждый объект Java потенциально имеет встроенный mutex и все, что Вам надо сделать, чтобы осуществить блокировку, — это объявить метод (или область) засинхронизированным. Точно так же события реализованные с ожиданиями подтверждениями вызываются внутри любого синхронизированного метода. Поэтому, если Вы знаете, как программировать на Java, Вы знаете, как программировать на C++ (как будто есть знатоки Java, не осведомленные о C++).
Далее: использование потоков на примере Наблюдателя за папками.
Практическое использование потоков
Когда измененяются папкиПеревод А. И. Легалова
Англоязычный оригинал находится на сервере компании Reliable Software
Вы когда-либо задались вопросом: каким оразом Проводник (Explorer) узнает о том, что некоторое действие должно модифицировать его окно, потому что был добавлен или удален файл в текущей папке некоторым внешним приложением? Больше этому можно не удивляться, потому что использование нашего Активного Объекта позволяет делать то же самое и даже больше. Есть несколько простых вызовов API, с помощью которых Вы можете запросить у файловой системы, чтобы она избирательно сообщила Вам относительно изменений для файлов и папок. Как только Вы устанавливаете такую вахту, ваш поток может отправляться спать, ожидая прихода событий. Файловая система отреагирует на событие, как только она обнаружит вид изменения, за которым вы наблюдаете.
Загрузка исходных текстов приложения FolderWatcher (zip архив 11K).
Без дальнейшей суеты унаследуем FolderWatcher из ActiveObject. Зададим в качестве источника уведомления — событие, а в качестве приемника уведомления — дескриптор к окна, отвечающего на уведомление. Исходное событие установлено в конструкторе FolderWatcher. Важно также запустить удерживаемый поток в конце конструктора.
class FolderWatcher : public ActiveObject {
public: FolderWatcher(char const* folder, HWND hwnd) : _notifySource (folder), _hwndNotifySink (hwnd) {
strcpy(_folder, folder);
_thread.Resume();
}
~FolderWatcher() {
Kill();
}
private:
void InitThread() {}
void Loop();
void FlushThread() {}
FolderChangeEvent _notifySource;
HWND _hwndNotifySink;
char _folder[MAX_PATH];
};
Все действия в ActiveObject происходят внутри метода Loop. Здесь мы устанавливаем "бесконечный" цикл, в котором поток должен ожидать событие. Когда событие происходит, мы проверяем флажок _isDying (как обычно) и посылаем специальное сообщение WM_FOLDER_CHANGE окну, которое имеет дело с уведомлениями. Это — не предопределенное сообщение Windows. Оно специально определено нами для передачи уведомления о папке от одного потока другому.
Происходит следующее: удерживаемый поток делает другой вызов API, чтобы позволить файловой системе, узнать, что она нуждается в большем количестве уведомлений. Затем управление возвращается к ожидающему потоку, находящемуся в состоянии сна. Одновременно Windows получает наше сообщение WM_FOLDER_CHANGE из очереди сообщений и посылает его оконной процедуре принимающего окна. Подробности чуть позже.
UINT const WM_FOLDER_CHANGE = WM_USER;
void FolderWatcher::Loop() {
for (;;) {
// Wait for change notification
DWORD waitStatus = WaitForSingleObject(_notifySource, INFINITE);
if (WAIT_OBJECT_0 == waitStatus) {
// If folder changed
if (_isDying) return;
PostMessage(_hwndNotifySink, WM_FOLDER_CHANGE, 0, (LPARAM)_folder);
// Continue change notification
if (!_notifySource.ContinueNotification()) {
// Error: Continuation failed
return;
}
} else {
// Error: Wait failed
return;
}
}
}
Рассмотрим, что происходит в оконной процедуре в ответ на наше специальное сообщение. Мы вызываем метод Контроллера OnFolderChange. Этот метод может делать все, что мы захотим. В Проводнике (Explorer) он регенерирует отображение содержимого папки, которую мы наблюдаем. В нашем примере он только вызывает простое окно сообщения. Обратите внимание, что мы передаем имя измененной папки как LPARAM. Совершенно неважно, как определить WPARAM и LPARAM, в сообщении, определяемом пользователем.
Между прочим, Наблюдатель Папки — только часть Контроллера.
case WM_FOLDER_CHANGE:
pCtrl->OnFolderChange(hwnd, (char const *)lParam);
return 0;
void Controller::OnFolderChange(HWND hwnd, char const * folder) {
MessageBox(hwnd, "Change Detected, "Folder Watcher", MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK);
}
class Controller {
public:
Controller(HWND hwnd, CREATESTRUCT * pCreate);
~Controller();
void OnFolderChange(HWND hwnd, char const *folder);
private:
