Какова стоимость использования автовыпуска в Какао?
Вы должны действительно использовать ограничение. Триггер «после вставки» фактически помещает вторую строку в таблице. , , и, надеюсь, никто не использует NOLOCK для чтения.
В любом случае, вам нужно посчитать строки и найти несколько вхождений. Это будет примерно так:
Create trigger tr_Duplicate on Utentes after INSERT as
begin
if exists (select 1
from utentes u join
inserted i
on u.nic = i.nic
group by u.nic
having count(*) > 1
)
begin
print 'NIC already in database';
rollback;
end;
end;
С триггером instead of вы не добавите новые строки в таблицу, если она уже существует:
create trigger tr_Duplicate on Utentes after INSERT as
begin
if exists (select 1
from utentes u join
inserted i
on u.nic = i.nic
)
begin
print 'NIC already in database';
rollback;
end;
else
begin
insert into utentes
select i.*
from inserted i;
end;
end;
11 ответов
Существует два затрат:
(Принятие Вас имеет опцию избежать автовыпущенных объектов.) Вы эффективно излишне расширяете время жизни своих объектов. Это может означать, что Ваш объем потребляемой памяти растет - излишне. На ограниченной платформе это может означать, что Ваше приложение завершается, если оно превышает предел. Даже если Вы не превышаете предел, он может заставить Вашу систему начинать подкачивать, который очень неэффективен.
Дополнительные издержки нахождения текущего пула автовыпуска, добавления автовыпущенного объекта к нему и затем выпуска объекта в конце (дополнительный вызов метода). Это не может быть большими издержками, но они могут сложить.
Лучшая практика на любой платформе должна стараться избегать автовыпуска, если Вы можете.
Отвечать на вопросы:
В конечном счете я должен использовать стратегию, где все автовыпущено, и использование сохраняют/выпускают, должно быть исключение из правила для конкретных случаев?
Как раз наоборот.
Или я должен обычно использовать, сохраняют/выпускают с автовыпуском, являющимся исключением для возвращенных объектов от удобных методов как [NSString stringWithEtc...]?
Необходимо всегда использовать, сохраняют/выпускают, если Вы можете - в случае NSString обычно нет никакой потребности использовать stringWithEtc методы как существуют initWithEtc эквиваленты.
См. также этот вопрос.
Я должен не согласиться с Jim Puls - я думаю, что не использование Автовыпуска делает отладку более трудного, потому что Вы, более вероятно, пропустите случайно память. Конечно, статический анализатор Лязга может взять некоторые из этих экземпляров, но для меня, небольшие накладные расходы в обычном использовании автовыпуска далеко омрачены моим кодом, являющимся менее вероятным быть багги.
И затем, только если у меня есть жесткий цикл, который я должен оптимизировать, будет я начинать смотреть на производительность. Иначе это - все просто преждевременная оптимизация, которая обычно считается плохой вещью.
Я удивлен, что никто еще не упомянул это. Самая большая причина избежать автовыпущенных объектов, когда Вы можете, не имеет никакого отношения к производительности. Да, все проблемы производительности, упомянутые здесь, абсолютно допустимы, но самая большая оборотная сторона для автовыпущения - то, что это делает отладку значительно более трудного.
Если у Вас есть сверхвыпущенный объект, это никогда не автовыпускается, тривиально легко разыскать. Если у Вас есть сообщаемый пользователями катастрофический отказ, который происходит периодически со следом где-нибудь к югу от NSPopAutoreleasePool, удачи...
Я обычно использую автовыпущенные объекты в эти дни, потому что они имеют тенденцию приводить к более простому, более легкому для чтения кода. Вы объявляете и инициализируете их, затем освобождаете отбрасывание из объема. Механически они существуют вполне немного дольше, но с точки зрения человека, пишущего код, это эквивалентно стеку, объявленному объектом в C++, автоматически разрушаемом, когда функциональные возвраты и его кадр уничтожаются.
В то время как существует потеря эффективности, в большинстве случаев это не значительно. Чем большая проблема, тем более существующие объекты и более позднее восстановление памяти могут привести к более фрагментированному адресному пространству. Если это - проблема, обычно довольно просто войти и переключиться на руководство, сохраняют/выпускают в нескольких горячих методах и улучшают его.
Как другие сказали, удобочитаемость превосходит производительность в невыполнении чувствительный код. Существует много случаев, куда использование автовыпущенных объектов приводит к большему количеству фрагментации памяти, но в любом случае где объект переживет пул, это не будет. В тех случаях единственная цена, которую Вы платите, находит стоимость нахождения корректного пула автовыпуска.
Одно преимущество для использования пулов автовыпуска - то, что они - исключение, безопасное без использования @try/@finally. У Greg Parker ('г-н Objective-C') есть большое сообщение, объясняя детали этого.
Я склонен использовать autorelease много как его меньше кода и делает это более читаемым, IMO. Оборотная сторона, как другие указали, то, что Вы расширяете время жизни объектов, таким образом временно с помощью большей памяти. На практике я должен все же найти злоупотребление autorelease чтобы быть значительной проблемой в любом приложении для Mac, я записал. Если использование верхней памяти, действительно кажется, проблема (который не вызывается подлинной утечкой), я просто добавляю в большем количестве пулов автовыпуска (после того, как профилирование, чтобы показать мне, где мне нужны они). Но в целом это довольно редко. Поскольку сообщение Mike Ash показывает (Graham Lee, связанный с ним), пулы автовыпуска имеют очень мало служебное и быстры. Существует почти нулевая стоимость для добавления большего количества пулов автовыпуска.
Предоставленный, это - все для приложений для Mac. В приложениях для iPhone, где память более трудна, можно хотеть быть консервативными в использовании автовыпуска. Но как всегда, напишите читаемый код сначала и затем оптимизируйте позже путем измерения, где медленные/интенсивно использующие память части.
Насколько я понимаю основная оборотная сторона к использованию автовыпуска - то, что Вы не знаете, когда объект будет наконец выпущен и уничтожен. Это могло потенциально заставить Ваше приложение использовать намного больше памяти, чем этому нужно к тому, если у Вас есть много автовыпущенных бродящих вокруг объектов, но еще не выпущенных.
Затраты:
- Время, чтобы определить местоположение пула автовыпуска текущего потока и добавить объект к нему.
- Память, занятая объектом, пока это не выпущено в некоторой более поздней точке.
Если Вы хотите быть очень консервативными со своим использованием памяти, необходимо избежать автовыпуска. Однако это - полезная техника, которая может сделать код более читаемым. Одержимо использование сохраняет/выпускает, подпадает под защиту "преждевременной оптимизации".
Если Вы находитесь в основном потоке обработки событий Какао (который Вы большую часть времени), пул автовыпуска освобожден, когда управление возвращается к обработчику событий. Если Ваш метод сокращен и не циклично выполняется по большим объемам данных, использование автовыпуска для задержки освобождения в конец цикла выполнения прекрасно.
Время для опасаний автовыпуска - когда Вы находитесь в цикле. Например, Вы выполняете итерации по адресной книге пользователя и возможно загружаете файл изображения для каждой записи. Если все те объекты изображения будут автовыпущены, то они накопятся в памяти, пока Вы не посетили всю адресную книгу. Если адресная книга является достаточно большой, у можно закончиться память. При выпуске изображений, как только Вы сделаны с ними в цикле, Ваше приложение может переработать память.
Если Вы не можете постараться не автовыпускать в цикле (он делается кодом, который Вы не написали и не можете изменить), можно также управлять NSAutoreleasePool в цикле сами в случае необходимости.
Так, помните использование автовыпуска в циклах (или методы, которые можно назвать от циклов), но не избегайте его, когда это может сделать код более читаемым.
Другие ответили, необходимо ли автовыпустить, но когда необходимо автовыпустить, высушите рано и часто высушивайте: http://www.mikeash.com/?page=pyblog/autorelease-is-fast.html
Я замечаю пример кода, который Вы предоставили, для iPhone. Apple конкретно рекомендует избежать автовыпущенных объектов для приложений для iPhone. Я не могу найти определенное обоснование, но они ковали эту точку в WWDC.
Одно примечание стороны для учета - то, при порождении нового потока необходимо установить новый пул Автовыпуска на том потоке, прежде чем Вы сделаете что угодно еще. Даже если Вы не используете объекты автовыпуска, возможности состоят в том, что что-то в API Какао.
Старый поток, но не работает для пользу для новых читателей.
Я использую автозапуск вместо сохранения / освобождения в зависимости от риска ошибок автоматического выпуска, специфичных для объекта, и размера объекта. Если я просто добавляю несколько крошечных UIImageViews или пару UILabels в свое представление, autorelease сохраняет код читабельным и управляемым. И когда представление будет удалено и отключено, эти подпредставления должны быть выпущены достаточно скоро.
Если, с другой стороны, мы говорим о UIWebView (высокий риск ошибок автозапуска) или, конечно, о некоторых данных, которые должны сохраняться до «смерти» объекта, то лучше всего сохранить / освободить .
Честно говоря, мои проекты еще не достигли таких масштабов, когда дополнительное «время пребывания» автоматически выпущенных объектов создало бы проблему с памятью. Для сложных приложений такая озабоченность вполне закономерна.
В любом случае, я не думаю, что универсальный подход будет правильным. Вы используете любой подход - или комбинацию подходов - подходящую для проекта, учитывая все упомянутые выше факторы.