Джонсон Харт - Системное программирование в среде Windows

• Название: Системное программирование в среде Windows
• Автор: Джонсон Харт
• Издательство: Издательский дом "Вильямс"
• Жанр: Программирование
• Год: 2005
• ISBN: 5-8459-0879-5

Эта книга посвящена вопросам разработки приложений с использованием интерфейса прикладного программирования операционных систем компании Microsoft (Windows 9х, Windows XP, Windows 2000 и Windows Server 2003). Основное внимание уделяется базовым системным службам, включая управление файловой системой, процессами и потоками, взаимодействие между процессами, сетевое программирование и синхронизацию. Рассматривается методика переноса приложений, написанных в среде Win32, в среду Win64. Подробно описываются все аспекты системы безопасности Windows и ее практического применения. Изобилие реальных примеров, доступных также и на Web-сайте книги, существенно упрощает усвоение материала.

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

---

} MSG_BLOCK;

/* Одиночный блок, подготовленный к заполнению новым сообщением. */

MSG_BLOCK mblock = { 0, 0, 0, 0, 0 };

DWORD WINAPI produce(void*);

DWORD WINAPI consume(void*);

void MessageFill(MSG_BLOCK*);

void MessageDisplay(MSG_BLOCK*);

DWORD _tmain(DWORD argc, LPTSTR argv[]) {

 DWORD Status, ThId;

 HANDLE produce h, consume_h;

 /* Инициализировать критический участок блока сообщения. */

 InitializeCriticalSection (&mblock.mguard);

 /* Создать два потока. */

 produce_h = (HANDLE)_beginthreadex(NULL, 0, produce, NULL, 0, &ThId);

 consume_h = (HANDLE)_beginthreadex (NULL, 0, consume, NULL, 0, &ThId); 

 /* Ожидать завершения потоков производителя и потребителя. */

 WaitForSingleObject(consume_h, INFINITE);

 WaitForSingleObject(produce_h, INFINITE);

 DeleteCriticalSection(&mblock.mguard);

 _tprintf(_T("Потоки производителя и потребителя завершили выполнение\n"));

 _tprintf(_T("Отправлено: %d, Получено: %d, Известные потери: %d\n"), mblock.sequence, mblock.nCons, mblock.nLost);

 return 0;

}

DWORD WINAPI produce(void *arg)

/* Поток производителя — создание новых сообщений через случайные */

/* интервалы времени. */

{

 srand((DWORD)time(NULL)); /* Создать начальное число для генератора случайных чисел. */

 while (!mblock.f_stop) {

  /* Случайная задержка. */

  Sleep(rand() / 100);

  /* Получить и заполнить буфер. */

  EnterCriticalSection(&mblock.mguard);

  __try {

   if (!mblock.f_stop) {

    mblock.f_ready = 0;

    MessageFill(&mblock);

    mblock.f_ready = 1;

    mblock.sequence++;

   }

  } __finally { LeaveCriticalSection (&mblock.mguard); }

 }

 return 0;

}

DWORD WINAPI consume (void *arg) {

 DWORD ShutDown = 0;

 CHAR command, extra;

 /* Принять ОЧЕРЕДНОЕ сообщение по запросу пользователя. */

 while (!ShutDown) { /* Единственный поток, получающий доступ к стандартным устройствам ввода/вывода. */

  _tprintf(_T("\n**Введите 'с' для приема; 's' для прекращения работы: "));

  _tscanf("%c%c", &command, &extra);

  if (command == 's') {

   EnterCriticalSection(&mblock.mguard);

   ShutDown = mblock.f_stop = 1;

   LeaveCriticalSection(&mblock.mguard);

  } else if (command == 'c') { /* Получить новый буфер для принимаемых сообщений. */ 

   EnterCriticalSection(&mblock.mguard);

   __try {

    if (mblock.f_ready == 0) _tprintf(_T("Новые сообщения отсутствуют. Повторите попытку.\n"));

    else {

     MessageDisplay(&mblock);

     mblock.nCons++;

     mblock.nLost = mblock.sequence – mblock.nCons;

     mblock.f_ready = 0; /* Новые сообщения отсутствуют. */

    }

   } __finally { LeaveCriticalSection (&mblock.mguard); }

  } else {

   tprintf(_T("Такая команда отсутствует. Повторите попытку.\n"));

  }

 }

 return 0;

}

void MessageFill(MSG_BLOCK *mblock) {

 /* Заполнить буфер сообщения содержимым, включая контрольную сумму и отметку времени. */

 DWORD i;

 mblock->checksum = 0;

 for (i = 0; i < DATA_SIZE; i++) {

  mblock->data[i] = rand();

  mblock->checksum ^= mblock->data[i];

 }

 mblock->timestamp = time(NULL);

 return;

}

void MessageDisplay(MSG_BLOCK *mblock) {

 /* Отобразить буфер сообщения, отметку времени и контрольную сумму. */

 DWORD i, tcheck = 0;

 for (i = 0; i < DATA_SIZE; i++) tcheck ^= mblock->data[i];

 _tprintf(_T("\nВремя генерации сообщения № %d: %s"), mblock->sequence, _tctime(&(mblock->timestamp)));

 _tprintf(_T("Первая и последняя записи: %х %х\n"), mblock->data[0], mblock->data[DATA_SIZE – 1]);

 if (tcheck == mblock->checksum) _tprintf(_T("УСПЕШНАЯ ОБРАБОТКА –>Контрольная сумма совпадает.\n"));

 else tprintf(_T("СБОЙ –>Несовпадение контрольной суммы. Сообщение запорчено.\n"));

 return;

}

Комментарии к примеру простой системы "производитель/потребитель"

Этот пример иллюстрирует некоторые моменты и соглашения, касающиеся программирования, которые будут важны для нас на протяжении этой и последующих глав.

• Объект CRITICAL_SECTION является частью объекта (блока сообщения), защиту которого он обеспечивает.

• Каждый доступ к сообщению осуществляется на критическом участке кода.

• Типом переменных, доступ к которым осуществляется разными потоками, является volatile.

• Использование обработчиков завершения гарантирует, что объекты CS будут обязательно освобождены. Хотя в данном случае эта методика и не является для нас существенной, она дополнительно гарантирует, что вызов функции LeaveCriticalSection не будет случайно опущен впоследствии при изменении кода программы. Имейте также в виду, что обработчик завершения ограничен использованием средств С, и его не следует использовать совместно с C++.

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

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

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

0 <= nLost + nCons <= sequence

Об этом важном свойстве далее еще будет идти речь.

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

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

Мьютексы

Объект взаимного исключения (mutual exception), или мьютекс (mutex), обеспечивает более универсальную функциональность по сравнению с объектом CRITICAL_SECTION. Поскольку мьютексы могут иметь имена и дескрипторы, их можно использовать также для синхронизации потоков, принадлежащих различным процессам. Так, два процесса, разделяющие общую память посредством отображения файлов, могут использовать мьютексы для синхронизации доступа к разделяемым областям памяти.

Объекты мьютексов аналогичны объектам CS, однако, дополнительно к возможности их совместного использования различными процессами, они допускают конечные периоды ожидания, а мьютексы, покинутые (abandoned) завершающимся процессом, переходят в сигнальное состояние.[29] Поток приобретает права владения мьютексом (или блокирует (block) мьютекс) путем вызова функции ожидания (WaitForSingleObject или WaitForMultipleObjects) по отношению к дескриптору мьютекса и уступает эти права посредством вызова функции ReleaseMutex.

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

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