Параллельное и распределенное программирование на С++
• PTHREAD_PROCESS_SHARED (разрешает блокировку чтения-записи, разделяемую любыми потоками, которые имеют доступ к памяти, выделенной для этой условной переменной, даже если потоки принадлежат различным процессам);
• PTHREAD_PROCESS_PRIVATE (Условная Переменная разделяется между потоками одного процесса)
• int pthread_condattr_setclock ( pthread_condattr_t * attr, clockid_t clock_id);
• int pthread_condattr_getclock ( const pthread_condattr_t * restrict attr, clockid_t * restrict clock_id); Устанавливает или возвращает атрибут clock атрибутного объекта условной переменной, заданного параметром attr . Атрибут clock представляет собой идентификатор часов, используемых для измерения лимита времени в функции pthread_cond_timedwait (). По умолчанию для атрибута clock используется идентификатор системных часов
Использование условных переменных для управления отношениями синхронизации
Условную переменную можно использовать для реализации отношений синхронизации, о которых упоминалось выше: старт-старт (CC), финиш-старт (ФС), старт-финиш (СФ) и финиш-финиш (ФФ). Эти отношения могут существовать между потоками одного или различных процессов. В листингах 5.4 и 5.5 представлены примеры реализации ФС- и ФФ-отношений синхронизации. В каждом примере определено два мьютекса. Один мьютекс используется для синхронизации доступа к общим данным, а другой — для синхронизации выполнения кода.
// Листинг 5.4. ФС-отношения синхронизации между
// двумя потоками
//. . .
float Number;
pthread_t ThreadA,ThreadB;
pthread_mutex_t Mutex, EventMutex;
pthread_cond_t Event;
void * worker1 (void *X) {
for(int Count = l;Count < 100;Count++){
pthread_mutex_lock(&Mutex);
Number++;
pthread_mutex_unlock(&Mutex);
cout << «worker1: число равно» << Number << endl;
if(Number == 50){
pthread_cond_signal(&Event);
}
}
cout << «Выполнение функиии worker1 завершено.» << endl;
return(0);
}
void * worker2 (void *X) {
pthread_mutex_lock(&EventMutex);
pthread_cond_wait(&Event,&EventMutex);
pthread_mutex_unlock(&EventMutex);
for(int Count = 1;Count < 50;Count++){
pthread_mutex_lock(&Mutex);
Number = Number + 20;
pthread_mutex_unlock(&Mutex);
cout << «worker2: число равно» << Number << endl;
}
cout « «Выполнение функции worker2 завершено.» « endl; return(0);
};
int main (int argc, char *argv[]) {
pthread_mutex_init(&Mutex,NULL);
pthread_mutex_init(&EventMutex,NULL);
pthread_cond_init(&Event, NULL);
pthread_create(&ThreadA, NULL, workerl, NULL);
pthread_create(&ThreadB, NULL, worker2 , NULL);
//. . .
return (0);
}
В листинге 5.4 показан пример реализации ФС-отношений синхронизации. Поток ThreadA не может завершиться до тех пор, пока не стартует поток ThreadB. Если значение переменной Number станет равным 50, поток ThreadA сигнализирует о этом потоку ThreadB. Теперь он может продолжать выполнение до самого конца Поток ThreadB не может начать выполнение до тех пор, пока не получит сигнал от потока ThreadA. Поток ThreadB использует объект EventMutex вместе с условной переменной Event. Объект Mutex используется для синхронизации доступа для записи значения разделяемой переменной Number. Для синхронизации различных событий и доступа к критическим разделам задача может использовать несколько мьютексов.
Пример реализации ФФ-отношений синхронизации показан в листинге 5.5.
// Листинг 5.5. ФФ-отношения синхронизации между // двумя потоками
//...
float Number;
pthread_t ThreadA, ThreadB ;
pthread_mutex_t Mutex, EventMutex;
pthread_cond_t Event;
void *workerl(void *X) {
for(int Count = l;Count < 10;Count++){
pthread_mu tex_l ock (&Mutex);
Number++;
pthread_mutex_unlосk(&Mutex);
cout « «workerl: число равно " << Number « endl;
}
pthread_mutex_lock(&EventMutex) ,-
cout « «Функция workerl в состоянии ожидания. " « endl;
pthread_cond_wait (&Event, &EventMutex) ;
pthread_mutex_unlock(&EventMutex);
return(0);
}
void *worker2 (void *X) {
for(int Count = l;Count < 100;Count++){
pthread_mutex_lock(&Mutex) ;
Number = Number * 2 ;
pthread_mutex_unlock(&Mutex) ;
cout « «worker2: число равно " « Number « endl;
}
pthread_cond_signal (&Event) ;
cout « «Функция worker2 послала сигнал " « endl; return(0);
}
int main(int argc, char *argv[]) {
pthread_mutex_init (&Mutex,NULL) ;
pthread_mutex_init (&EventMutex,NULL) ;
pthread_cond_init (&Event, NULL) ;
pthread_create(&ThreadA, NULL,workerl, NULL);
pthread_create (&ThreadB, NULL, worker2, NULL) ;
//.. .
return (0);
}
В листинге 5.5 поток ThreadA не может завершиться до тех пор, пока не завершится поток ThreadB. Поток ThreadA должен выполнить цикл 10 раз, а ThreadB — 100. Поток ThreadA завершит выполнение своих итераций раньше ThreadB, но будет ожидать до тех пор, пока поток ThreadB не просигналит о своем завершении.
CC- и СФ-отношения синхронизации невозможно реализовать подобным образом. Эти методы используются для синхронизации пор я дка выполнени я процессов.
Объектно-ориентированный подход к синхронизации
Одно из преимуществ объектно-ориентированного программирования состоит в защите, которую обеспечивает инкапсуляция компонентов данных объекта. Инкапсуляция может обеспечить для пользователя объектов «стратегии доступа к объектам и принципы их применения» [ 24 ]. В примерах, представленных в этой главе, за применяемые стратегии доступа вся ответственность возлагалась на пользователя данных. С помощью объектов и инкапсуляции ответственность можно переложить с пользователя данных на сами данные. При таком подходе создаются данные, которые, в отличие от функций, являются безопасными для потоков.
Для реализации такого подхода данные многопоточного приложения (по возможности) необходимо инкапсулировать с помощью С++-конструкций class или struct. Затем инкапсулируйте такие механизмы синхронизации, как семафоры, блокировки для обеспечения чтения-записи и мьютексы событий. Если данные или механизмы синхронизации представляют собой объекты, создайте для них интерфейсный класс. Наконец, объедините объект данных с объектами синхронизации посредством наследования или композиции, чтобы создать объекты данных, которые будут безопасны для потоков. Этот подход подробно рассматривается в главе 11.
Резюме
Для координации порядка выполнения процессов и потоков (синхронизация задач), а также доступа к разделяемым данным (синхронизация данных) можно использовать различные механизмы синхронизации. Су щ ествует четыре основных вида отношений синхронизации задач. Отношение вида «старт-старт» (CC) означает, что задача А не может начаться до тех пор, пока не начнется задача В. Отношение вида «финиш-старт» (ФС) означает, что задача А не может завершиться до тех пор, пока не начнется задача В. Отношение вида «старт-финиш» (СФ) означает, что задача А не может начаться до тех пор, пока не завершится задача В. Отношение вида «финиш-финиш» (ФФ) означает, что задачаА не может завершиться до тех пор, пока не завершится задача В. Для реализации этих отношений синхронизации задач можно использовать условную переменную pthread_cond_t, которая определена стандартом POSIX.