Привет, мой читатель с Хабра!

Знаешь ли ты о том, что такое многопоточное программирование? Если да, то это хорошо! Если же нет, то придётся почитать немного скучноватой теории про такую известную технологию программирования, как многопоточное программирование, а затем мы копнём эту тему глубже…

Теория многопоточного программирования

Как известно, программы состоят из программного кода и данных. При запуске программы процессор уделяет немного внимания её коду. Команды в коде программы выполняются одна за другой. Вот пример самой простой однопоточной программы:

#include <stdio.h> // Импорт файла stdio.h для получения доступа к функции printf()

int main(){ // Главная функция программы
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251); // Устанавливаем для консоли таблицу символов CP-1251
  printf("Привет, Хабр!"); // Печатаем сообщение "Привет, Хабр!" на экране
  return 0; // Сообщаем системе, что всё хорошо
}

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

Реализация многопоточного программирования

Многопоточное программирование в Win32 API

Чтобы написать многопоточную программу для Windows, мы будем использовать Win32 API. Первым делом нам понадобится функция для создания потока. Вот она (для того, чтобы объявления функций можно было удобно читать, я удалил все ключевые слова типа WINAPI или WINBASEAPI и оставил их только там, где нужно):

HANDLE CreateThread (LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId)

Здесь lpThreadAttributes — структура атрибутов безопасности (можно указать NULL), dwStackSize — размер стека потока в байтах (при указании 0 используется размер стека потока‑родителя), lpStartAddress — указатель на функцию, в которой есть код для нового потока. Она должна объявляться так:

DWORD WINAPI Thread(LPVOID){
  // Код потока
}

Дальше. Параметр dwCreationFlags определяет, готов ли поток к немедленному выполнению. Указывай значение CREATE_SUSPENDED, чтобы он был приостановлен при создании. lpParamerer — параметр, который передаётся потоку как параметр вышеупомянутой функции (можно указать NULL). lpThreadId указывает на DWORD‑переменную, в которую будет помещён идентификатор нового потока (тоже можно указать NULL).

Примечание: вместо функции CreateThread из Win32 API всегда рекомендуется использовать функцию _beginthreadex. Эта функция всегда работает корректнее и безопаснее функции CreateThread, а вместо функции ExitThread также всегда рекомендуется использовать функцию _endthreadex. А начиная с версии C++11 для реализации потоков всегда рекомендуется использовать стандартный и абсолютно кроссплатформенный класс std::thread. Вот такие вот «всегда‑рекомендации».

Чтобы завершить своё выполнение, поток может вызвать в своём коде такую функцию:

VOID ExitThread (DWORD dwExitCode)

Здесь единственный параметр — dwExitCode, код завершения. Он указывает, хорошо ли проработал поток или во время его выполнения случилась какая‑либо ошибка.

Одна из самых опасных штучек — функция TerminateThread — позволяет одному потоку принудительно завершить работу другого потока. Но использование этой функции очень чревато, поэтому здесь я её не привожу.

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

WINBOOL GetExitCodeThread (HANDLE hThread, LPDWORD lpExitCode)

Здесь hThread — дескриптор потока, а lpExitCode — указатель на DWORD‑переменную, в которую будет помещён код завершения (если поток все ещё выполняется, то вернётся значение STILL_ACTIVE).

У потока есть свой счётчик приостановок. Если он равен 0, то поток выполняется. Если он не равен 0, то поток приостанавливает свою работу. Счётчик приостановок можно уменьшать и увеличивать этими функциями:

DWORD SuspendThread (HANDLE hThread)
DWORD ResumeThread (HANDLE hThread)

hThread — дескриптор потока. Функции возвращают предыдущее значение счётчика приостановок. 0xFFFFFFFF — ошибка.

Кстати, а как ожидать завершения работы потока? Для этого есть специальная функция:

DWORD WaitForSingleObject (HANDLE hHandle, DWORD dwMilliseconds)

hHandle — дескриптор потока, dwMilliseconds — время в миллисекундах, в течении которого функция будет ждать завершения потока — указывай 0 для немедленного возвращения состояния потока или INFINITE для постоянного ожидания завершения потока.

Функция может вернуть следующие значения:

• WAIT_OBJECT_0 — поток завершил свою работу;

• WAIT_TIMEOUT — вышеупомянутое время ожидания завершения потока истекло;

• WAIT_FAILED — провал, во время запроса состояния произошла ошибка. Есть ещё одно возвращаемое значение этой функции, но о нём мы поговорим позже.

Также есть ещё одна функция для ожидания завершения сразу нескольких потоков, но, по‑моему, нам будет достаточно этой функции. Этими функциями можно ожидать не только завершения потоков, но и процессов, и так далее

В итоге можно привести пример простейшей многопоточной программы:

// Импорт всех необходимых файлов
#include <stdio.h>
#include <windows.h>

DWORD WINAPI FirstThread(LPVOID){ // Функция потока №1
  printf("Привет, Хабр, от потока №1!\n"); // Печать сообщения
  ExitThread(0); // Выход с кодом 0
}

DWORD WINAPI SecondThread(LPVOID){ // Функция потока №2
  printf("Привет, Хабр, от потока №2!"); // Печать сообщения
  ExitThread(0); // Выход с кодом 0
}

int main(){
  HANDLE hFirst, hSecond; // Объявление дескрипторов потоков
  // Установка таблицы символов CP-1251
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251);
  // Создание потоков
  hFirst = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&FirstThread, 0, 0, NULL);
  hSecond = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&SecondThread, 0, 0, NULL);
  // Ожидание завершения работы потоков
  WaitForSingleObject(hFirst, INFINITE);
  WaitForSingleObject(hSecond, INFINITE);
  return 0; // Выход с кодом 0
}

Ой, как здорово получается!

Результат выполнения программы‑примера

Многопоточное программирование в библиотеке Pthreads

Библиотека Pthreads предназначена для работы с потоками в POSIX‑совместимых системах (да и не только). Пробегусь кратко по её функциям:

int pthread_create(pthread_t *th, const pthread_attr_t *attr, void *(* func)(void *), void *arg)

Функция создаёт новый поток. Здесь th — указатель на переменную типа pthread_t, в которую будет помещён дескриптор нового потока, attr — некие атрибуты для потока, func — указатель на функцию с кодом потока, arg — аргумент, который ему передаётся. Функция возвращает 0, если создание потока было успешным.

void pthread_exit(void *res)

Как и функция ExitThread в Win32 API, функция pthread_exit заведует тем, чтобы потоки завершали свою работу, возвращая какой‑либо код завершения — здесь он определяется параметром *res. Стоит отметить, что в отличие от функции ExitThread, здесь можно передать код завершения любого типа (это не обязательно должен быть int или DWORD).

int pthread_join(pthread_t t, void **res);

Функция действует аналогично функции WaitForSingleObject в Win32 API — ждёт, пока поток не завершится. t — дескриптор потока, res — результат, который поток возвращает. В случае успешного ожидания сама функция вернёт 0. В случае неудачи — положительное значение.

Вот я и максимально кратко пробежался по библиотеке Pthreads. Но это ещё не конец статьи…

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

Теория синхронизации потоков

К сожалению, многопоточное программирование — не совсем безобидная штука. Да, если они просто выводят сообщения на экран, как в нашем предыдущем примере, то никаких проблем нет. Но если они начинают получать общий доступ к каким‑либо ресурсам, то начинаются проблемы…

Представь себе один и только один принтер, подключённый к ПК. Представил? А теперь представь себе программу с 2-мя потоками — первый из них хочет напечатать на принтере, предположим, название операционной системы (например, Windows 10), а второй — номер её сборки (например, 19044). После того, как потоки получают доступ к принтеру, они вместе делают то, что хотели. В результате на бумаге вряд ли отпечатается осмысленный текст — скорее на ней отпечатается абракадабра типа «НазНование мер сбОС: орWindкиows: 10 19044». Критическая секция кода — фрагмент кода, который может выполняться один и только одним потоком. Если этот фрагмент выполняется сразу несколькими потоками, то это может привести к беспорядочным, удивительным и просто глючным событиям.

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

Реализация синхронизации потоков

Для решения проблемы критической секции в Win32 API предусмотрены специальный тип объекта — CRITICAL_SECTION и функции к нему:

VOID InitializeCriticalSection (LPCRITICAL_SECTION lpCriticalSection)
VOID DeleteCriticalSection (LPCRITICAL_SECTION lpCriticalSection)
VOID EnterCriticalSection (LPCRITICAL_SECTION lpCriticalSection)
VOID LeaveCriticalSection (LPCRITICAL_SECTION lpCriticalSection)
WINBOOL TryEnterCriticalSection (LPCRITICAL_SECTION lpCriticalSection)

Первые 2 функции отвечают за инициализацию и удаление критической секции. 3-я и 4-я функции — за вход и выход из критической секции, а 5-я — за попытку входа в критическую секцию. Во всех функциях 1 параметр — указатель на переменную типа CRITICAL_SECTION.

Итак, снова представим нашу вышеупомянутую программу по печати названия ОС и её номера сборки. Её надо поправить: сначала создаётся переменная типа CRITICAL_SECTION, затем вызывается функция InitializeCriticalSection с указателем на эту переменную, потом 1-й поток вызывает функцию EnterCriticalSection с тем же указателем, входит в критическую секцию и спокойно печатает на принтере название ОС. 2-й поток тоже хочет получить доступ к принтеру и тоже вызывает функцию для входа, но из‑за того, что в критической секции уже находится 1-й поток, 2-й поток блокируется и начинает ждать, пока 1-й поток не завершит свою работу с принтером и не выйдет из критической секции. Когда 1-й поток завершает свою работу, он вызывает функцию LeaveCriticalSection и в критическую секцию входит 2-й поток. Он печатает номер сборки и тоже выходит из критической секции. В конце вызывается функция DeleteCriticalSection для удаления критической секции.

Как ты уже увидел, кроме всех этих 4-х функций есть ещё одна функция — TryEnterCriticalSection. Эта функция проверяет, занята ли критическая секция. Если да, то функция автоматически возвращает FALSE. Если критическая секция открыта и никем не занята, то поток входит в эту критическую секцию, а функция возвращает TRUE.

Вот так работает решение проблемы критической секции. Но есть ещё 2 объекта синхронизации — семафоры и мьютексы. Про семафоры я писать пока не буду (и так слишком большая статья получается), а вот про мьютексы напишу.

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

HANDLE CreateMutex (LPSECURITY_ATTRIBUTES lpMutexAttributes, WINBOOL bInitialOwner, LPCSTR lpName)
WINBOOL ReleaseMutex (HANDLE hMutex)

Первая функция создаёт новый мьютекс и возвращает его дескриптор. В ней lpMutexAttributes — структура атрибутов безопасности, bInitialOwner позволяет потоку, который вызвал функцию, сразу вступить во владение мьютексом, а lpName — название мьютекса (имя мьютекса не может быть больше 260 символов, также вместо имени можно указать NULL). Вторая функция позволяет освободить (разблокировать) мьютекс, которым владеет поток.

Наверное, ты спросишь: «Стоп! А как заблокировать мьютекс? В критическую секцию можно просто войти функцией EnterCriticalSection, а в случае с мьютексами…»

Заблокировать мьютекс просто — надо вызвать вышеупомянутую функцию WaitForSingleObject с дескриптором мьютекса в качестве 1-ого параметра и временем ожидания (или значением INFINITE) в качестве 2-ого параметра. Если мьютекс уже заблокирован другим потоком, то функция либо завершит своё выполнение из‑за истёкшего времени, либо будет постоянно ждать разблокировки мьютекса (если 2-й параметр функции будет задан как INFINITE).

Замечательное свойство мьютексов — свойство быть покинутыми. Если в потоке, скажем, произошёл какой‑то глюк (или наивный программист написал некорректный код), и он преспокойно вызвал функцию ExitThread, не освободив перед этим мьютекс (функцией ReleaseMutex в Win32 API), то мьютекс крайне обидится на этот «неправильный» поток, и станет покинутым мьютексом. Все потоки, которые были заблокированы из‑за этого мьютекса, сразу же будут разблокированы, а функция WaitForSingleObject по отношению к покинутому мьютексу сразу вернёт значение WAIT_ABANDONED_0. Именно про это значение я и обещал «поговорить позже» в разделе «Многопоточное программирование в Win32 API». И, как видишь, я пообещал — и сделал!

В следующей части…

Много чего осталось за бортом нашего большого корабля, бороздящего по просторам многопоточного программирования. А что именно осталось — я напишу прямо сейчас. Если ты хочешь продолжение моей статьи, то стимулируй меня в комментариях, и я, возможно, сделаю это самое продолжение.

Вот что тебя будет ждать в следующей части:

• Теория семафоров и их реализация в Win32 API;

• Теория событий и их реализация в Win32 API;

• Реализация мьютексов с помощью библиотеки Pthreads;

• Изюминка следующей части — захватывающая история про взаимоблокировки;

• Ну, и, возможно, ещё что‑нибудь.

О, я вижу, ты дочитал эту статью до конца? Тогда ты большой молодец и я дарю тебе один совет по синхронизации потоков! Вот он, этот совет, внизу:

LONG InterlockedIncrement (LONG volatile *lpAddend);
LONG InterlockedDecrement (LONG volatile *lpAddend);
LONG InterlockedExchange (LONG volatile *Target, LONG Value);
LONG InterlockedExchangeAdd (LONG volatile *Addend, LONG Value);
LONG InterlockedCompareExchange (LONG volatile *Destination, LONG Exchange, LONG Comperand);

Ну, вот и всё. До свидания, мой читатель! Спасибо за то, что прочитал эту статью!