Деструкторы должны быть ориентированы на многопотоковое исполнение?

Я думаю, что у Вас есть более фундаментальная проблема. Не должно быть законно уничтожить Ваш объект на одном потоке, в то время как другой поток все еще называет функции членства. Это сам по себе неправильно.

, Даже если Вы успешно охраняете свой деструктор с критическими разделами, что происходит, когда другой поток начинает выполнять остаток от функции? Это будет делать так на удаленном объекте, который (в зависимости от он - местоположение выделения) будет памятью мусора или простой недопустимый объект.

необходимо изменить код, чтобы гарантировать, что объект не разрушен, в то время как все еще используемый.

Не попытка иметь значение. Если, как Вы говорите, порядок вызовов инвертируется тогда, Вы называете функцию членства на разрушенном объекте, и это собирается перестать работать. Синхронизация не может зафиксировать ту логическую ошибку (для начинающих, вызов функции членства попытался бы получить объект блокирования, это было разрушено).

Я второй комментарий от Neil ButterWorth. Абсолютно, Объекты, ответственные за удаление и доступ к myclass, должен иметь проверку на этом.

Эта синхронизация запустит на самом деле с момента объект типа, MyClass создается.

Определите "ориентированный на многопотоковое исполнение". Это возможно два наиболее плохо понятых слова в современных вычислениях.

, Но если существует возможность деструктора, вводимого дважды от двух различных потоков (поскольку использование объектов синхронизации подразумевает) Ваш код находится в глубоком doo-doo. Объекты, которые удаляют объект, о котором Вы спрашиваете, должны управлять этим - это (вероятно), на том уровне, что синхронизация должна происходить.

При доступе к глобальным переменным, Вам, возможно, понадобилась бы потокобезопасность, да

, например, Мой класс "Окна" добавляет себя к списку "knownWindows" в конструкторе и удаляет себя в деструкторе. "knownWindows" должен быть ориентирован на многопотоковое исполнение, таким образом, они оба блокируют взаимное исключение, в то время как они делают это.

, С другой стороны, если Ваш деструктор только получает доступ к членам уничтожаемого объекта, у Вас есть вопросы проектирования.

Я видел случай с потоками ACE, где поток работает на объекте ACE_Task_Base, и объект уничтожается от другого потока. Деструктор получает блокировку и уведомляет содержавший поток, прежде, чем ожидать на условии. Поток, который работает на сигнале ACE_Task_Base, сигнализирует об условии в выходе и позволяет деструктору завершиться и первый выход потока:

class PeriodicThread : public ACE_Task_Base
{
public:
   PeriodicThread() : exit_( false ), mutex_()
   {
   }
   ~PeriodicThread()
   {
      mutex_.acquire();
      exit_ = true;
      mutex_.release();
      wait(); // wait for running thread to exit
   }
   int svc()
   {
      mutex_.acquire();
      while ( !exit_ ) { 
         mutex_.release();
         // perform periodic operation
         mutex_.acquire();
      }
      mutex_.release();
   }
private:
   bool exit_;
   ACE_Thread_Mutex mutex_;
};

В этом коде, деструктор должен использовать методы потокобезопасности, чтобы гарантировать, что объект не уничтожается перед потоком, который работает svc () выходы.

Существуют привязки для зарубежных инструментальных средств, но инструментарий eXene был разработан как собственный для SML и для использования функций Concurrent ML. Я использовал его много лет назад и нашел его очень гладким подходит для языка и удовольствие использовать. Но у него нет гениальной библиотеки компонентов, которые вы найдете в более широко используемых инструментах.

Вещи немного сложнее, чем простая контрольная точка. Файл может быть удален, когда последний VLF, содержащий записи журнала о создании файла, неактивен. См. раздел Сбор мусора FILESTREAM .

В ваших комментариях говорится: " НЕТ Доступа к участникам здесь" Я думаю, что только поток, который создал объект, должен уничтожить его, так что от какого другого потока вы бы его защищать?

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

Пример:

• main () создать объект A
  • Объект A содержит объект B
    • объект B содержит объект C
      • объект C создает поток, который обращается к объектам A и B
      • объект C запускает деструктор, ожидая, пока его поток завершит
    • объект B запускает
  • объект A запускает
• основной() возвращает

Деструкторы для объектов A и B вообще не должны думать о потоках, а деструктор объекта C должен только реализовать некоторый механизм связи (например, ожидание события) с потоком, который он выбрал для создания.

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