Марк Митчелл - Программирование для Linux. Профессиональный подход
В листинге 4.7 показано, как осуществить задуманное. Для хранения файлового указателя в функции main() создается ключ, запоминаемый в переменной thread_log_key. Эта переменная является глобальной, поэтому она доступна всем потокам. Когда поток начинает выполнять свою потоковую функцию, он открывает журнальный файл и сохраняет указатель на него в своем ключе. Позднее любой поток может вызвать функцию write_to_thread_log(), чтобы записать сообщение в свой журнальный файл. Эта функция извлекает из области потоковых данных указатель на журнальный файл и помещает в файл требуемое сообщение.
Листинг 4.7. (tsd.c) Создание отдельного журнального файла для каждого потока с помощью области потоковых данных#include <malloc.h>
#include <pthread.h>
#include <stdio.h>
/* Ключ, связывающий указатель журнального файла с каждым
потоком. */
static pthread_key_t thread_log_key;
/* Запись параметра MESSAGE в журнальный файл текущего потока. */
void write_to_thread_log(const char* message) {
FILE* thread_log =
(FILE*)pthread_getspecific(thread_log_key);
fprintf(thread_log, "%sn", message);
}
/* Закрытие журнального файла, на который указывает параметр
THREAD_LOG. */
void close_thread_log(void* thread_log) {
fclose((FILE*)thread_log);
}
void* thread_function(void* args) {
char thread_log_filename[20];
FILE* thread_log;
/* Создание имени журнального файла для текущего потока. */
sprintf(thread_log_filename, "thread%d.log",
(int)pthread_self());
/* Открытие журнального файла. */
thread_log = fopen(thread_log_filename, "w");
/* Сохранение указателя файла в области потоковых данных,
под ключом thread_log_key. */
pthread_setspecific(thread_log_key, thread_log);
write_to_thread_log("Thread starting.");
/* Далее идет основное тело потока... */
return NULL;
}
int main() {
int i;
pthread_t threads[5];
/* Создание ключа, который будет связывать указатели
журнальных файлов с областью потоковых данных. Функция
close_thread_log() закрывает все файлы. */
pthread_key_create(&thread_log_key, close_thread_log);
/* Создание потоков. */
for (i = 0; i < 5; ++i)
pthread_create(&(threads[i]), NULL, thread_function, NULL);
/* Ожидание завершения всех потоков. */
for (i = 0; i < 5; ++i)
pthread_join(threads[i], NULL);
return 0;
}
Обратите внимание на то, что в функции thread_function() не нужно закрывать журнальный файл. Просто когда создавался ключ, функция close_thread_log() была назначена функцией очистки данного ключа. Когда бы поток ни завершился, операционная система Linux вызовет эту функцию, передав ей значение ключа, соответствующее данному потоку. В функции close_thread_log() и происходит закрытие файла.
4.3.1. Обработчики очистки
Функции очистки ключей гарантируют, что в случае завершения или отмены потока не произойдет потерн ресурсов. Но иногда возникает необходимость в создании функции, которая будет связана не с ключом, дублируемым между потоками, а с обычным ресурсом. Такая функция называется обработчиком очистки.
Обработчик очистки вызывается при завершении потока. Он принимает один аргумент типа void*, который передается обработчику при его регистрации. Это позволяет использовать один и тот же обработчик для удаления нескольких экземпляров ресурса.
Обработчик очистки — это временная мера, требуемая только тогда, когда поток завершается или отменяется, не закончив выполнять определенный участок кода. При нормальных обстоятельствах ресурс должен удаляться явно.
Для регистрации обработчика следует вызвать функцию pthread_cleanup_push(), передав ей указатель на обработчик и значение его аргумента. Каждому такому вызову должен соответствовать вызов функции pthread_cleanup_pop(), которая отменяет регистрацию обработчика. Для удобства эта функция принимает дополнительный целочисленный флаг. Если он не равен нулю, при отмене регистрации выполняется операция очистки.
В листинге 4.8 показан фрагмент программы, в котором обработчик очистки применяется для удаления динамического буфера при завершении потока.
Листинг 4.8. (cleanup.c) Фрагмент программы, содержащий обработчик очистки потока#include <malloc.h>
#include <pthread.h>
/* Выделение временного буфера. */
void* allocate_buffer(size_t size) {
return malloc(size);
}
/* Удаление временного буфера. */
void deallocate_buffer(void* buffer) {
free(buffer);
}
void do_some_work() {
/* Выделение временного буфера. */
void* temp_buffer = allocate_buffer(1024);
/* Регистрация обработчика очистки для данного буфера. Этот
обработчик будет удалять буфер при завершении или отмене
потока. */
pthread_cleanup_push(deallocate_buffer, temp_buffer);
/* Выполнение других действий... */
/* Отмена регистрации обработчика. Поскольку функции передается
ненулевой аргумент, она выполняет очистку, вызывая функцию
deallocate_buffer(). */
pthread_cleanup_pop(1);
}
В данном случае функции pthread_cleanup_pop() передается ненулевой аргумент, поэтому функция очистки deallocate_buffer() вызывается автоматически. В данном простейшем случае можно было в качестве обработчика непосредственно использовать стандартную библиотечную функцию free().
4.3.2. Очистка потоковых данных в C++
Программисты, работающие на C++, привыкли к тому, что очистку за них делают деструкторы объектов. Когда объект выходит за пределы своей области видимости, либо по достижении конца блока, либо вследствие возникновения исключительной ситуации, среда выполнения C++ гарантирует вызов деструкторов для тех автоматических переменных, у которых они есть. Это удобный механизм очистки, работающий независимо от того, как осуществляется выход из конкретного программного блока.
Тем не менее, если поток вызывает функцию pthread_exit(), среда выполнения C++ не может гарантировать вызов деструкторов для всех автоматических переменных, находящихся в стеке потока. Чтобы этого добиться, нужно вызвать функцию pthread_exit() в рамках конструкции try/catch, охватывающей все тело потоковой функции. При этом перехватывается специальное исключение ThreadExitException.
Программа, приведенная в листинге 4.9, иллюстрирует данную методику. Потоковая функция сообщает о своем намерении завершить поток, генерируя исключение ThreadExitException, а не вызывая функцию pthread_exit() явно. Поскольку исключение перехватывается на самом верхнем уровне потоковой функции, все локальные переменные, находящиеся в стеке потока, будут удалены правильно.
Листинг 4.9. (cxx-exit.cpp) Безопасное завершение потока в C++#include <pthread.h>
class ThreadExitException {
public:
/* Конструктор, принимающий аргумент RETURN_VALUE, в котором
содержится возвращаемое потоком значение. */
ThreadExitException(void* return_value) :
thread_return_value_(return_value) {
}
/* Реальное завершение потока. В программу возвращается
значение, переданное конструктору. */
void* DoThreadExit() {
pthread_exit(thread_return_value_);
}
private:
/* Значение, возвращаемое в программу при завершении потока. */
void* thread_return_value_;
};
void do_some_work() {
while (1) {
/* Здесь выполняются основные действия... */
if (should_exit_thread_immediately())
throw ThreadExitException(/* поток возвращает */NULL);
}
}
void* thread_function(void*) {
try {
do_some_work();
} catch (ThreadExitException ex) {
/* Возникла необходимость завершить поток. */
ex.DoThreadExit();
}
return NULL;
}
4.4. Синхронизация потоков и критические секции
Программирование потоков — нетривиальная задача, ведь большинство потоков выполняется одновременно. К примеру, невозможно определить, когда система предоставит доступ к процессору одному потоку, а когда — другому. Длительность этого доступа может быть как достаточно большой, так и очень короткой, в зависимости от того, как часто система переключает задания. Если в системе есть несколько процессоров, потоки могут выполняться одновременно в буквальном смысле.
