void *pVectorMemory =// Выделить блок общей памяти,
mallocShared(sizeof(SharedOoubleVec)); // обьем которой достаточен
// для хранения объекта SharedDoubleVec
SharedDoubleVec *pv =// Использовать "new с явным
new (pVectorMemory) SharedDoubleVec; // размещением" для создания
// объекта SharedDoubleVec:
// см. далее.
// Использование объекта (через pv)
pv->~SharedDoubleVec();// Уничтожить объект в общей памяти
freeShared(pVectorMemory);// Освободить исходный блок
// общей памяти
Надеюсь, смысл происходящего достаточно ясен из комментариев. В общих чертах происходит следующее: мы выделяем бок общей памяти и конструируем в ней vector, использующий общую память для своих внутренних операций. После завершения работы с вектором мы вызываем его деструктор и освобождаем память, занимаемую вектором. Код не так уж сложен, но все-таки он не сводится к простому объявлению локальной переменной, как прежде. Если у вас нет веских причин для того, чтобы в общей памяти находился сам контейнер (а не его элементы), я рекомендую избегать четырехшагового процесса «выделение/конструирование/уничтожение/освобождение».
Несомненно, вы заметили: в приведенном фрагменте проигнорирована возможность того, что mallocShared может вернуть null. Разумеется, в окончательной версии следовало бы учесть такую возможность. Кроме того, конструирование vector в общей памяти производится конструкцией «new с явным размещением», описанной в любом учебнике по С++.
Рассмотрим другой пример использования распределителей памяти. Предположим, у нас имеются две кучи, представленные классами Heap1 и Неар2. Каждый из этих классов содержит статические функции для выделения и освобождения памяти:
class Heap1 {
public:
static void* alloc(size t numBytes, const void* memoryBlockToBeNear);
static void dealloc(void *ptr);
};
class Heap2 {...}; // Тот же интерфейс alloc/dealloc
Далее предположим, что вы хотите разместить содержимое контейнеров STL в заданных кучах. Сначала следует написать распределитель, способный использовать классы Heap1 и Неар2 при управлении памятью:
template<typename T,typename Heap>
SpecificHeapAllocator{
public:
...
pointer allocate(size_type numObjects,const void *localityHint=0) {
return static_cast<pointer> (Heap::alloc(numObjects*sizeof(T), localityHint)):
}
void deallocate(pointer ptrToMemory,size_type numObjects) {
Heap::dealloc(ptrToMemory);
}
...
};
Затем SpecialHeapAllocator группирует элементы контейнеров:
vector<int.SpecificHeapAllocator<int,Heap1> > v; // Разместить элементы
set<int,SpecificHeapAllocator<int,Heap1> > s: // v и s в Heapl
list<Widget,
SpecificHeapAllocator<Widget,Heap2> > L; // Разместить элементы
map<int.string.less<int>,// L и m в Heap2
SpecificHeapAllocator<pair<const int,string>. Heap2> > m;
В приведенном примере очень важно, чтобы Heap1 и Неар2 были типами, а не объектами. В STL предусмотрен синтаксис инициализации разных контейнеров STL разными объектами распределителей одного типа, но я не буду его приводить. Дело в том, что если бы Heap1 и Неар2 были бы объектами вместо типов, это привело бы к нарушению ограничения эквивалентности, подробно описанного в совете 10.
Как показывают приведенные примеры, распределители приносят пользу во многих ситуациях. При соблюдении ограничения об эквивалентности однотипных распределителей у вас не будет проблем с применением нестандартных распределителей для управления памятью, группировки, а также использования общей памяти и других специализированных пулов.
Совет 12. Разумно оценивайте потоковую безопасность контейнеров STL
Мир стандартного С++ выглядит старомодным и не подверженным веяниям времени. В этом мире все исполняемые файлы компонуются статически, в нем нет ни файлов, отображаемых на память, ни общей памяти. В нем нет графических оконных систем, сетей и баз данных, нет и других процессов. Вероятно, не стоит удивляться тому, что в Стандарте не сказано ни слова о программных потоках. О потоковой безопасности в STL можно уверенно сказать только одно: что она полностью зависит от реализации.
Конечно, многопоточные программы распространены весьма широко, поэтому большинство разработчиков STL стремится к тому, чтобы их реализации хорошо работали в многопоточных условиях. Но даже если они хорошо справятся со своей задачей, основное бремя остается на ваших плечах. Возможности разработчиков STL в этой области ограничены, и вы должны хорошо понимать, где проходят эти границы.
«Золотой стандарт» поддержки многопоточности в контейнерах STL (которым руководствуется большинство разработчиков) был определен компанией SGI и опубликован на ее web-сайте, посвященном STL [21]. Фактически в нем сказано, что в лучшем случае можно надеяться на следующее:
•безопасность параллельного чтения. Несколько потоков могут одновременно читать содержимое контейнера, и это не помешает его правильной работе. Естественно, запись в контейнер при этом не допускается;
•безопасность записи в разные контейнеры. Несколько потоков могут одновременно производить запись в разные контейнеры.
Обращаю ваше внимание: это то, на что вы можете надеяться, но не рассчитывать. Одни реализации предоставляют такие гарантии, другие — нет.
Многопоточное программирование считается сложной задачей, и многие программисты желают, чтобы реализации STL изначально обеспечивали полную потоковую безопасность. Это избавило бы их от необходимости самостоятельно синхронизировать доступ. Конечно, это было бы очень удобно, однако добиться этой цели очень сложно. Рассмотрим несколько способов реализации полной потоковой безопасности контейнеров:
•блокировка контейнера на время вызова любой функции;
•блокировка контейнера в течение жизненного цикла каждого возвращаемого итератора (например посредством вызова begin или end);
•блокировка контейнера на протяжении работы каждого алгоритма, вызванного для этого контейнера. В действительности это бессмысленно, поскольку, как будет показано в совете 32, алгоритм не располагает средствами идентификации контейнера, с которым он работает. Тем не менее, мы изучим этот вариант — будет поучительно увидеть, почему он в принципе неработоспособен.
Рассмотрим следующий фрагмент, который ищет в vector<int> первое вхождение числа 5 и заменяет его нулем:
vector<int> v;
vector<int>::iterator first5(find(v.begin(),v.end(),5)); // Строка 1
if (first5 != v.end()) {// Строка 2
*first5 = 0;// Строка 3
}
В многопоточной среде существует вероятность того, что другой поток изменит содержимое v сразу же после выполнения строки 1. Если это произойдет, сравнение first5 с v.end в строке 2 становится бессмысленным, поскольку содержимое v будет не тем, каким оно было в конце строки 1. Более того, такая проверка может привести к непредсказуемым результатам, поскольку третий поток может перехватить управление между строками 1 и 2 и сделать first5 недействительным (например, при выполнении вставки вектор может заново выделить память, вследствие чего все итераторы данного вектора станут недействительными. За подробностями о перераспределении памяти обращайтесь к совету 14). Присваивание *first5 в строке 3 тоже небезопасно, поскольку между строками 2 и 3 другой поток может удалить элемент, на который указывает (или, по крайней мере, указывал раньше) итератор first5.
Ни одно из описанных выше решений с блокировкой не решает этих проблем. Вызовы begin и end в строке 1 сразу возвращают управление, сгенерированные ими итераторы остаются действительными только до конца строки, а find тоже возвращает управление в конце строки.
Чтобы этот фрагмент был потоково-безопасным, блокировка v должна сохраняться от строки 1 до строки 3. Трудно представить, каким образом реализация STL могла бы автоматически придти к такому выводу. А если учесть, что использование примитивов синхронизации (семафоров, мьютексов[1] и т. д.) обычно сопряжено с относительно высокими затратами, еще труднее представить, каким образом реализация могла бы сделать это без значительного снижения быстродействия по сравнению с программами, которым априорно известно, что в строках 1-3 с v будет работать только один программный поток.
Понятно, почему в решении проблем многопоточности не стоит полагаться на реализацию STL. Вместо этого в подобных случаях следует самостоятельно синхронизировать доступ. В приведенном примере это может выглядеть так:
vector<int> v;
getMutexFor(v);
vector<int>::iterator first5(find(v.begin(),v.end(),5));
if (first5 != v.end()) {// Теперь эта строка безопасна
*first5 = 0:// И эта строка тоже
}
releaseMutexFor(v);
В другом, объектно-ориентированном, решении создается класс Lock, который захватывает мьютекс в конструкторе и освобождает его в деструкторе, что сводит к минимуму вероятность вызова getMutexFor без парного вызова releaseMutexFor. Основа такого класса (точнее, шаблона) выглядит примерно так:
