Реализация многопоточности в C с использованием Posix Threads (Петри)

Используя pthreads, разработчики могут проектировать программы, которые выполняют фоновые вычисления, обрабатывают несколько клиентских соединений одновременно или параллелизуют задачи обработки данных. Библиотека абстрагирует детали низкоуровневой операционной системы, давая тонкое понимание поведения потоков. Твердое понимание pthreads необходимо для любого C-программиста, работающего над чувствительными к производительности или параллельными приложениями. Эта статья охватывает основополагающие концепции, предоставляет практические примеры кода и исследует примитивы синхронизации и лучшие практики.

Основные понятия pthreads

Перед написанием многопоточного кода важно ознакомиться с основными типами данных и функциями, которые предоставляются в виде pthreads:

• Thread: Легкий блок исполнения, который работает в адресном пространстве процесса.Множественные потоки имеют одну и ту же память, дескрипторы файлов и другие ресурсы, что делает связь между потоками эффективной, но также вносит необходимость тщательной синхронизации.
• pthread t: Непрозрачный тип данных, используемый для представления идентификатора потока. Это не целое число; вы должны рассматривать его как ручку, которая возвращается и используется в вызовах, подобных .
• pthread create: Функция, используемая для генерации новой нити. Для этого требуется четыре аргумента: указатель на переменную , указатель на объект атрибута нити (обычно по умолчанию), функция, которую будет выполнять нить (указатель на функцию, которая возвращает и принимает один аргумент ), и аргумент для перехода к этой функции.
• pthread join: Блокирующий вызов, который ожидает окончания определённого потока. Он также извлекает возвращаемое значение из начальной процедуры потока.
• pthread mutex t: Тип данных для блокировки mutex (взаимное исключение), который является фундаментальным примитивом синхронизации, используемым для защиты общих данных от одновременного доступа.
• pthread cond t: переменная состояния, используемая в сочетании с мутексами, чтобы позволить потокам ждать, пока конкретные условия станут истинными.

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

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

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

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void* print_message(void* message) {
 char* msg = (char*) message;
 printf("%s\n", msg);
 return NULL;
}

int main(void) {
 pthread_t thread1, thread2;

 char* message1 = "Hello from Thread 1!";
 char* message2 = "Hello from Thread 2!";

 if (pthread_create(&thread1, NULL, print_message, (void*) message1) != 0) {
 perror("pthread_create");
 exit(EXIT_FAILURE);
 }
 if (pthread_create(&thread2, NULL, print_message, (void*) message2) != 0) {
 perror("pthread_create");
 exit(EXIT_FAILURE);
 }

 pthread_join(thread1, NULL);
 pthread_join(thread2, NULL);

 return 0;
}

В этой программе создаёт два потока, каждый из которых вызывает . Звонки гарантируют, что основной поток ждёт завершения обоих детских потоков перед выходом. Обратите внимание, что порядок вывода не гарантируется: планировщик операционной системы может перемешать выполнение двух потоков, поэтому вы можете увидеть «Привет из Thread 2!», напечатанный перед первым сообщением.

Хорошей практикой является всегда проверять значение возврата и других функций pthread. Они возвращают ноль на успех или положительный код ошибки на отказ (аналогично . Программа выше использует и для изящного управления сбоями.

Жизненный цикл и атрибуты

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

• Отделить состояние : Создается ли нить как соединяемая (по умолчанию) или отсоединенная.
• Размер стека: позволяет выделить конкретный размер стека для резьбы.
• Политика планирования и приоритет : Для управления потоками в реальном времени (требуется соответствующие привилегии).

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

Синхронизация с мутексами

Когда несколько потоков одновременно получают доступ к общим данным, существует риск рас данных — ситуаций, когда результат зависит от непредсказуемого порядка выполнения потока. Чтобы избежать этого, pthreads предоставляет mutexes. mutex гарантирует, что только один поток за раз может выполнить критический раздел кода. Типичная картина:

1. Инициировать мутекс с (или статически с ).
2. Заблокируйте mutex перед доступом к общим данным с .
3. Разблокируйте мутекс после критического раздела с помощью .
4. Уничтожьте мутекс, когда он больше не нужен .

Следующий пример демонстрирует общий счетчик, инкрементированный двумя потоками с надлежащей защитой mutex:

#include <pthread.h>
#include <stdio.h>

int counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void* increment(void* arg) {
 for (int i = 0; i < 1000000; i++) {
 pthread_mutex_lock(&lock);
 counter++;
 pthread_mutex_unlock(&lock);
 }
 return NULL;
}

int main(void) {
 pthread_t t1, t2;

 pthread_create(&t1, NULL, increment, NULL);
 pthread_create(&t2, NULL, increment, NULL);

 pthread_join(t1, NULL);
 pthread_join(t2, NULL);

 printf("Final counter value: %d\n", counter); // Guaranteed to be 2000000

 pthread_mutex_destroy(&lock);
 return 0;
}

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

Мутексные типы и обработка ошибок

POSIX определяет несколько типов мутексов, управляемых атрибутом type:

• Обычный: простой мутекс, который не обнаруживает тупик.Попытка снова заблокировать его из той же нити приводит к парадлок.
• Проверка ошибок: обеспечивает обнаружение ошибок; если один и тот же поток пытается перезагрузить уже принадлежащий мутекс, он возвращается .
• Рекурсивный : Позволяет владеющей нитью несколько раз блокировать мутекс без затормаживания. Каждый замок должен быть спарен с разблокировкой.
• По умолчанию : Реализация может отображаться на любую из вышеперечисленных.На Linux (glibc) она эквивалентна .

Всегда проверяйте обратную стоимость функций блокировки/разблокировки mutex. В производственном коде вы должны обрабатывать потенциальные ошибки (например, для недействительного mutex, , если вызывающая нить не владеет mutex).

Переменные условия

Переменные состояния позволяют нитям ждать, пока определенное условие станет истинным. Они всегда используются с mutex. Типичный шаблон: нить блокирует mutex, проверяет предикат (общая переменная), и если предикат ложный, он вызывает , который атомарно высвобождает mutex и укладывает нить спать. Когда другая нить сигнализирует условие (с или ), ожидающая нить повторно приобретает mutex и перепроверяет предикат.

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

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int data_ready = 0;

void* producer(void* arg) {
 sleep(1); // Simulate work
 pthread_mutex_lock(&mutex);
 data_ready = 1;
 printf("Producer: data ready\n");
 pthread_cond_signal(&cond);
 pthread_mutex_unlock(&mutex);
 return NULL;
}

void* consumer(void* arg) {
 pthread_mutex_lock(&mutex);
 while (!data_ready) {
 pthread_cond_wait(&cond, &mutex);
 }
 printf("Consumer: processing data\n");
 pthread_mutex_unlock(&mutex);
 return NULL;
}

int main(void) {
 pthread_t prod, cons;
 pthread_create(&cons, NULL, consumer, NULL);
 pthread_create(&prod, NULL, producer, NULL);
 pthread_join(prod, NULL);
 pthread_join(cons, NULL);
 pthread_mutex_destroy(&mutex);
 pthread_cond_destroy(&cond);
 return 0;
}

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

Трансляция vs. сигнал

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

Читать-письменные блоки

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

Пример:

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

void* reader(void* arg) {
 pthread_rwlock_rdlock(&rwlock);
 // read shared data
 pthread_rwlock_unlock(&rwlock);
 return NULL;
}

void* writer(void* arg) {
 pthread_rwlock_wrlock(&rwlock);
 // modify shared data
 pthread_rwlock_unlock(&rwlock);
 return NULL;
}

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

Общие подводные камни и лучшие практики

Многопоточное программирование на C является мощным, но подверженным ошибкам. Ниже приведены частые проблемы и способы их избежать.

Расы данных и тупики

Гонка данных происходит, когда два потока получают доступ к одному и тому же местоположению памяти без синхронизации и по меньшей мере одна запись. C11 добавил квалификатор , но pthreads не обеспечивает атомные операции напрямую; вы должны использовать блокировки. A deadlock происходит, когда два или более потока ждут друг друга, чтобы выпустить замок. Чтобы предотвратить тупики:

• Всегда приобретайте замки в последовательном глобальном порядке.
• Используйте или , если вы не можете гарантировать заказ.
• Держите критические секции как можно короче.

Безопасность библиотечных функций

Многие функции стандартной библиотеки C не являются безвредными для потоков. Например, использует внутреннее статическое состояние. Используйте версии для повторного входа (например, ) или защищайте вызовы с помощью mutex. Такие функции, как , также не являются безвредными для потоков; предпочтите с семенем в одной нити.

Размер стека и ограничения ресурсов

Каждый поток имеет свой собственный стек. Размер стека по умолчанию может быть большим (например, 8 МБ на Linux). Создание тысяч потоков с стеками по умолчанию может истощить память. Используйте для настройки размеров стека, когда вы знаете требования к потоку. Также имейте в виду ограничения по каждому процессу: ограничивает количество потоков, которые может создать один процесс.

Отмена и очистка ниток