В чем разница между атомными и неатомическими атрибутами?

Это объясняется в компании Apple документации , но ниже приведены некоторые примеры того , что на самом деле происходит. Обратите внимание , что не существует «атомный» ключевое слово, если вы не указываете «неатомической» , то свойство атомной, но с указанием «атомных» явно приведет к ошибке.

//@property(nonatomic, retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    return userName;
}

- (void) setUserName:(UITextField *)userName_ {
    [userName_ retain];
    [userName release];
    userName = userName_;
}

Теперь, атомный вариант немного сложнее:

//@property(retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    UITextField *retval = nil;
    @synchronized(self) {
        retval = [[userName retain] autorelease];
    }
    return retval;
}

- (void) setUserName:(UITextField *)userName_ {
    @synchronized(self) {
      [userName_ retain];
      [userName release];
      userName = userName_;
    }
}

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

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

атомное

• поведение по умолчанию
• обеспечит настоящий процесс завершается с помощью ЦПУ, перед тем другой процесс получает доступ к переменной
• не быстро, так как он обеспечивает процесс будет завершен полностью

Неатомарный

• НЕ по умолчанию
• быстрее (для синтезированного кода, то есть, для переменных, созданных с помощью @property и @synthesize)
• не поточно-
• может привести к неожиданному поведению, когда два различных процесса доступа к той же переменной в то же время

Лучший способ понять разницу использует следующий пример.

Предположу , что существует атомное строковое свойство называется «имя», и , если вы звоните [self setName:@"A"]из потока А, вызовите [self setName:@"B"]из потока B, и вызвать [self name]из потока C, то все операции на разных потоках будут выполняться последовательно , что означает , если один поток выполняет сеттер или геттер, то другие потоки будут ждать.

Это делает «имя» свойство чтения / записи в безопасности, но если другой поток, D, вызывает [name release]одновременно , то эта операция может произвести сбой , потому что нет сеттер / добытчика вызова участвует здесь. А это значит , объект чтения / запись сейфа (ATOMIC), но не поточно-а другая нить может одновременно передавать любой тип сообщений объекта. Разработчик должен обеспечить безопасность потоков для таких объектов.

Если «название» собственности неатомическое, то все нити в приведенном выше примере - А, В, С и D будут выполняться одновременно производя любой непредсказуемый результат. В случае атомных, либо один из А, В или С, будет выполняться первым, но по-прежнему D может выполняться параллельно.

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

Что такое функциональное различие между этими 3?

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

выполнение

ОК. Первое , что я хотел бы прояснить, что реализация блокировки от реализации и абстрагироваться. Луис использует @synchronized(self)в своем примере - я видел это как общий источник путаницы. Реализация не на самом деле использовать @synchronized(self); он использует объект уровня спин - блокировки . Иллюстрации Луи хороши для иллюстрации высокого уровня с использованием конструкции мы все знакомы, но это важно знать , что она не использует @synchronized(self).

Другое отличие состоит в том, что атомные свойства сохранят / цикл выпуска своих объекты в поглотителе.

Представление

Вот интересная часть: Производительность использования атомной собственности доступ в безальтернативной (например однопоточных) случаях может быть действительно очень быстро в некоторых случаях. В менее идеальных случаях, использование атомных доступов может стоить более чем в 20 раз накладных расходов nonatomic. В то время как Contested случай с использованием 7 темы , было 44 раз медленнее , за три байта структуры (2,2 ГГц Core i7 Quad Core, x86_64). Три байта структура является примером очень медленной собственности.

Интересно примечание стороны: определяемый пользователь аксессоры трех байт структуры было в 52 раза быстрее, чем синтезированные атомные аксессоры; или 84% скорость синтезированных неатомических аксессоров.

Объекты в оспариваемых случаях также могут превышать 50 раз.

Из-за количество оптимизаций и изменений в реализации, это довольно трудно измерить реальные последствия в этих контекстах. Вы можете часто услышать что-то вроде «Доверься это, если вы не профиль и найти это проблема». Из-за уровень абстракции, это на самом деле довольно трудно измерить реальное воздействие. Подбирая фактические расходы из профилей может быть очень много времени, и из-за абстракции, весьма неточен. Как хорошо, ARC против MRC может сделать большую разницу.

Так что давайте шаг назад, не делая упор на реализации имущества доступов, мы будем включать обычную подозреваемые , как objc_msgSendи изучить некоторые реальные результаты высокого уровня для многих вызовов на NSStringпоглотитель в бесспорных случаях (значения в секундах):

• MRC | неатомической | реализованные вручную добытчики: 2
• MRC | неатомической | синтезировали газопоглотитель: 7
• MRC | атомное | синтезировали газопоглотитель: 47
• ARC | неатомической | синтезировали геттер: 38 (примечание: АРК добавление ссылок количества велосипедного здесь)
• ARC | атомное | синтезировали газопоглотитель: 47

Как вы уже, наверное, догадались, счетчик ссылок активности / задействуя является существенным фактором с Атомикс и под АРК. Вы также увидите большие различия в спорных случаях.

Хотя я обратить пристальное внимание на производительность, я до сих пор говорят Семантика в первую очередь! , В то же время, производительность является низким приоритетом для многих проектов. Тем не менее, зная детали выполнения и затраты на технологии , которые вы используете , конечно , не помешает. Вы должны использовать правильную технологию для ваших потребностей, целей и способностей. Надеюсь , это поможет вам сэкономить несколько часов сравнений и помочь вам сделать более обоснованное решение при разработке своих программ.

Атомный = потокобезопасность

Неатомарный = Нет потокобезопасность

безопасность Тема:

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

В нашем контексте:

Если поток изменяет значение экземпляра измененного значение доступно для всех потоков, и только один поток может изменить значение в то время.

Где использовать atomic:

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

Проявление atomic:

Не так быстро , как , nonatomicпотому что nonatomicне требует какой - либо сторожевой работы на том , что от выполнения.

Где использовать nonatomic:

Если переменная экземпляра не собирается быть изменено несколькими потоками вы можете использовать его. Это повышает производительность.

Я нашел довольно хорошо поставил объяснения атомных и неатомарных свойств здесь . Вот некоторые релевантный текст из того же:

«атомный» означает , что он не может быть разбит. В терминах / программирования OS вызов атомной функции одна , которая не может быть прервана - целая функция должна быть выполнена, а не выгружена из CPU обычного контекста ОС переключений , пока не будет завершено. Только в случае , если вы не знали: так как процессор может сделать только одну вещь в то время, операционная система вращает доступ к процессору для всех запущенных процессов в небольших временных срезах, чтобы дать иллюзиюмногозадачности. Планировщик CPU может (и делает) прервать процесс в любой момент его исполнение - даже при вызове функции середины. Так что для таких действий, как обновление общих переменных счетчика, когда два процесса могут попытаться обновить переменную в то же время, они должны быть выполнены «атомарной», то есть, каждое действие обновления должен закончить в полном объеме, прежде чем какой-либо другой процесс может быть заменен на ЦПУ.

Так что я бы догадаться, что атомное в данном случае означает, что методы чтения атрибут не может быть прервана - в действительности это означает, что переменная (s) считывается с помощью метода не может изменить свое значение на полпути через, потому что другой поток / вызов / функция получает местами на процессор.

Поскольку atomicпеременные не может быть прервана, значение содержащегося в них в любой точке (токарно-замок) гарантированно неповрежденные , хотя, обеспечивая блокировку потоков делает доступ к ним медленнее. non-atomicпеременные, с другой стороны, не делают такой гарантии , но предлагают роскошь быстрого доступа. Подводя итог, пойти с , non-atomicкогда вы знаете , что ваши переменные не будут доступны несколько потоков одновременно и ускорить процесс .

После прочтения так много статей, Stack сообщения от перелива и сделать демо-приложения для проверки атрибутов переменных свойств, я решил поставить всю информацию атрибутов вместе:

1. atomic // По умолчанию
2. nonatomic
3. strong = retain // По умолчанию
4. weak = unsafe_unretained
5. retain
6. assign // По умолчанию
7. unsafe_unretained
8. copy
9. readonly
10. readwrite // По умолчанию

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

1. atomic

   • atomic означает, что только один доступ нити переменной (статический тип).
   • atomic потокобезопасен.
   • Но это очень медленный процесс в производительности
   • atomic поведение по умолчанию
   • Атомные аксессоры в не мусор, собранной среде (т.е. при использовании сохранить / релиз / autorelease) будет использовать блокировку, чтобы гарантировать, что другой поток не мешает правильной установке / получения значения.
   • Это на самом деле не является ключевым словом.
     
     

   Пример:

       @property (retain) NSString *name;
   
       @synthesize name;
   

2. nonatomic

   • nonatomic означает, что нить, множественный доступ с переменным (динамическим типом).
   • nonatomic является поточно-небезопасным.
   • Но это быстро в производительности
   • nonatomicНЕ по умолчанию поведения. Нам нужно добавить nonatomicключевое слово в атрибуте свойства.
   • Это может привести к неожиданному поведению, когда два различных процесса (потоков) доступ к той же переменной в то же время.
     
     

   Пример:

       @property (nonatomic, retain) NSString *name;
   
       @synthesize name;
   

Самый простой ответ первый: Там нет никакой разницы между вашими вторыми двумя примерами. По умолчанию доступ к свойствам являются атомарным.

Атомные аксессоры в не мусор, собранной среде (т.е. при использовании сохранить / релиз / autorelease) будет использовать блокировку, чтобы гарантировать, что другой поток не мешает правильной установке / получения значения.

Смотрите « Производительность и Threading в раздел» о Objective-C документации от Apple 2.0 для более определенной информации и для других соображений при создании многопоточных приложений.

Atomic:

Атомные гарантирует, что доступ к собственности будет осуществляться в атомном образом. Например, он всегда возвращает полностью инициализированы объекты, любой ПОЛУЧИТЬ / набор свойства на одну нить должна быть завершена до другой может получить доступ к нему.

Если представить следующую функцию, возникающую на две нити сразу можно понять, почему результаты не были бы довольно.

-(void) setName:(NSString*)string
{
  if (name)
  {
    [name release]; 
    // what happens if the second thread jumps in now !?
    // name may be deleted, but our 'name' variable is still set!
    name = nil;
  }

  ...
}

Плюсы: Возвращение полностью инициализированных объектов каждый раз делает его лучшим выбором в случае многопоточности.

Минусы: Производительность удар, делает выполнение немного медленнее

Неатомарный:

В отличии от Atomic, он не обеспечивает полностью инициализирован объект возвращает каждый раз.

Плюсы: Очень быстрое исполнение.

Минусы: Шансы на стоимости мусора в случае многопоточности.

Атомный означает только один поток получает доступ к переменной (статический тип). Атомный потокобезопасно, но это очень медленный процесс.

Неатомический означает несколько потоков доступ к переменным (динамический типу). Неатомический является поточно-небезопасно, но это быстро.

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

Это только обеспечивает безопасность потока; это не гарантирует , что. То , что я имею в виду, вы нанимаете опытный водитель для вас автомобиля, еще не гарантирует , автомобиль не встретит аварию. Однако, вероятность остается малейшем.

Atomic - это не может быть разбита, так что результат не ожидается. С неатомическим - когда другой доступом нитки зона памяти может изменить его, так что результат является неожиданным.

Код Обсуждение:

Атомный сделать геттер и сеттер недвижимости Потокобезопасного. например, если и написано:

self.myProperty = value;

потокобезопасен.

[myArray addObject:@"Abc"] 

НЕ поточно.

Там нет такого ключевого слова «атомный»

@property(atomic, retain) UITextField *userName;

Мы можем использовать выше как

@property(retain) UITextField *userName;

См Stack Overflow вопрос я получаю вопросы , если я использую @property (атомная, сохранить) NSString * MyString .

По умолчанию является atomic, это означает , что он делает стоить вам производительность всякого раза , когда вы используете свойство, но это поточно. Что Objective-C делает, установлен замок, поэтому только фактический поток может получить доступ к переменной, до тех пор , как сеттер / добытчика выполняется.

Пример с MRC из свойства с ИВАР _internal:

[_internal lock]; //lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;

Таким образом, эти последние два одинаковы:

@property(atomic, retain) UITextField *userName;

@property(retain) UITextField *userName; // defaults to atomic

С другой стороны , делает nonatomicничего не добавляют к коду. Так что только поточно если код механизма безопасности самостоятельно.

@property(nonatomic, retain) UITextField *userName;

Ключевые слова не должны быть написаны как атрибут первой собственности вообще.

Не забывайте, что это вовсе не означает, что свойство в целом потокобезопасно. Только метод вызов инкубационного / геттера есть. Но если вы используете метод установки и после этого геттер одновременно с 2-мя различными нитями, она может быть нарушена слишком!

Атомный (по умолчанию)

Атомный по умолчанию: если вы ничего не вводите, ваша собственность является атомарным. Атомное свойство гарантирует, что если вы пытаетесь читать из него, вы получите обратно действительное значение. Он не делает никаких гарантий относительно того, что может быть это значение, но вы получите обратно хорошие данные, а не только вредную память. То, что это позволяет сделать, если у вас есть несколько потоков или несколько процессов, указывающих на одной переменных, один поток может читать и другой поток может писать. Если они попали в то же время, читатель поток гарантированно получить один из двух значений: либо до изменения и после изменения. Что атомное не дает вам какие-либо рода гарантии, о которых из тех значений, которые вы могли бы получить. Атомный действительно часто путают с бытием потокобезопасной, и что не является правильным. Вы должны гарантировать вашу безопасность нить другие способы.

неатомической

На оборотной стороне, неатомический, как вы можете догадаться, просто означает, что «не делает этого атомарных вещи.» То, что вы потеряете то, что гарантирует, что вы всегда получите обратно что-то. Если вы пытаетесь прочитать в середине записи, вы можете получить обратно данные для мусора. Но, с другой стороны, вы идете немного быстрее. Поскольку атомные свойства должны сделать некоторую магию, чтобы гарантировать, что вы получите обратно значение, они немного медленнее. Если это свойство, что вы обращаетесь к много, вы можете упасть до неатомического, чтобы убедиться, что вы не подвергаясь, что скорость казни.

Подробнее здесь: https://realm.io/news/tmi-objective-c-property-attributes/

• -Atomic означает только один доступ нити переменной (статический тип).
• -Atomic является поточно.
• бут это очень медленный процесс в производительности

Как объявить:

Как атомное по умолчанию так,

@property (retain) NSString *name;

И в файле реализации

self.name = @"sourov";

Предположим, что задача, связанные с тремя свойствами являются

 @property (retain) NSString *name;
 @property (retain) NSString *A;
 @property (retain) NSString *B;
 self.name = @"sourov";

Все свойства работают параллельно (например, асинхронно).

Если вы называете «имя» из потока А ,

А также

В то же время, если вы звоните

[self setName:@"Datta"]

с резьбой B ,

Теперь если * имя свойство неатомическое затем

• Она возвращает значение «Датта» для A
• Она возвращает значение «Датта» для B

Вот почему не атомная называется нить небезопасно Но, но это быстро в производительности из-за параллельного выполнения

Теперь если * имя свойства атомное

• Это обеспечит значение «Sourov» для
• Тогда он будет возвращать значение «Датта» для B

Вот почему атомный называются Потокобезопасным и Вот почему он называется чтение-запись в безопасности

Такая операция ситуация будет выполнять последовательно. И Медленная производительность

- неатомический означает нить, множественный доступ с переменным (динамическим типом).

- неатомическое это нить небезопасно.

- но это быстро в производительности

-Nonatomic НЕ по умолчанию поведения, нам нужно добавить неатомическое ключевое слово в атрибуте свойства.

Для Swift В подтверждении, что Swift свойство неатомическое в смысле ObjC. Одна из причин, так что вы думаете о том, является ли достаточной для ваших нужд за собственность атомарность.

Справка: https://forums.developer.apple.com/thread/25642

Фро подробнее , пожалуйста , посетите веб - сайт http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html

Если вы используете свойство в многопоточном коде, тогда вы сможете увидеть разницу между неатомическими и атомными атрибутами. Неатомический быстрее, чем атомная и атомный потокобезопасно, не неатомические.

Vijayendra Трипатхи уже дали пример для многопоточной среды.

Перед тем, как начать: Вы должны знать , что каждый объект в памяти должен быть высвобождены из памяти для новой записи произойдет. Вы не можете просто написать на вершине чего - то , как вы делаете на бумаге. Вы должны первым удалить (dealloc), а затем вы можете написать на него. Если в тот момент, когда Стирание делается (или наполовину сделано) , и ничего до сих пор не было написали (или половина писал) , и вы пытаетесь прочитать это может быть весьма проблематично! Атомные и неатомические поможет вам рассматривать эту проблему по - разному.

Сначала прочитайте этот вопрос , а затем прочитать ответ Bbum в . Кроме того , то прочитать мое резюме.

atomic ВСЕГДА гарантировать

• Если два разных человека хотят читать и писать в то же время, бумага не будет просто гореть! -> Ваше приложение никогда не рухнет, даже в состоянии гонки.
• Если один человек пытается писать и писал только 4 из 8 писем написано, то не может читать в середине, чтение может быть сделано только тогда , когда все 8 букв написано -> Нет чтения (не получить) будет происходить на «поток , который до сих пор пишет», то есть , если есть 8 байт в байты , которые будут написано, и только 4 байта написано - до этого момента, вы не можете читать из него. Но так как я сказал , что это не катастрофа , то она будет читать из значения в autoreleased объекта.
• Если перед тем писать вы уже стерта то , что ранее было написано на бумаге , а затем кто - то хочет читать вы можете еще прочитать. Как? Вы будете читать с чем - то похож на Mac OS Мусорное ведро (как мусорное ведро все еще не 100% стерта ... это в подвешенном состоянии) ---> Если ThreadA это читать в то время как ThreadB уже dealloced писать, вы бы могли либо получить значение из окончательного полностью письменного значения по ThreadB или получить что - то из autorelease бассейна.

Сохранил отсчеты путь , в котором память управляется в Objective-C. При создании объекта, то есть сохранить счетчик 1. При передаче объекта сохранить сообщение, его сохранение счетчика увеличивается на 1. При передаче объекта , сообщение об освобождении его сохранить счетчик уменьшается на 1. Когда вы отправки объекта в autorelease сообщение , его сохранить счетчик уменьшается на 1 на каком - то этапе в будущем. Если object's сохраняют отсчет уменьшается до 0, он удаляется.

• Атомный не гарантирует безопасность потока, хотя его полезным для достижения безопасности потока. Тема безопасности относительно того , как вы пишете код / какой поток очереди вы чтения / записи с. Это гарантирует только не crashable многопоточность.

Чего ждать?! Есть многопоточность и безопасность потоков отличается?

Да. Многопоточность означает: несколько потоков могут прочитать общую часть данных, в то же время и не врезаться, но это не гарантирует, что вы не читаете из не autoreleased значения. С безопасностью потока, это гарантирует, что вы читаете это автоматически не выпущено. Причина, по которой мы не делаем все атомное по умолчанию является, потому что это снижение производительности и для большинства вещей, на самом деле не нужна безопасность потока. Несколько частям нашего кода это нужно и для тех немногих частей, мы должны написать наш код в потокобезопасном способе с использованием замков, семафора или синхронизации.

nonatomic

• Поскольку не существует такой вещи, как Mac OS Trash Bin, то никто не заботится ли или нет, вы всегда получите значение (<- Это потенциально может привести к аварии), ни кто заботится, если кто-то пытается прочитать на полпути через вас писать (хотя на полпути писать в памяти очень отличается от полпути записи на бумаге, в памяти он может дать вам сумасшедшее глупое значение из ранее, в то время как на бумаге, вы видите только половину того, что было писали) -> не гарантирует не врезаться, потому что он не использует autorelease механизма.
• Не гарантирую полный письменные значения для чтения!
• Быстрее, чем атомное

В целом они отличаются в 2-х аспектах:

• Сбои или не из-за того, или не имеющее autorelease бассейна.

• Разрешение для чтения прямо в середине «еще не закончил писать или пустое значение» или не допуская и только что позволяет читать , когда значение полностью написано.

Прежде чем обсуждать о признаках @property, вы должны знать, что использование @property. @property предлагает способ определения информации о том, что класс предназначен для инкапсуляции. Если вы объявляете объект / переменную с помощью @property, то, что объект / переменная будет доступна для других классов, импортирующих его класс. Если вы объявляете объект, используя @property в заголовочном файле, то вы должны синтезировать его с помощью @synthesize в файле реализации.

Пример:

.h класс

@interface ExampleClass : NSObject
   @property (nonatomic, retain) NSString *name;
@end

.m класс

@implementation ExampleClass
   @synthesize name;
@end

Теперь компилятор будет синтезировать аксессор методы для имени.

ExampleClass *newObject=[[ExampleClass alloc]init];
NSString *name1=[newObject name]; // get 'name'
[obj setName:@“Tiger”];

Список атрибутов @property: атомный. неатомический. сохранить. копия. неизменяемые. читай пиши. назначить. сильный.

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

Пример :

@property NSString *name; //by default atomic
@property (atomic)NSString *name; // explicitly declared atomic

неатомический: Это не потокобезопасно. Вы можете использовать атрибут неатомического свойства, чтобы указать, что синтезированные аксессор просто установить или вернуть значение непосредственно, без каких-либо гарантий относительно того, что произойдет, если то же самое значение обращается одновременно из разных потоков. По этой причине, это быстрее, чтобы получить доступ к неатомическому свойству, чем атомарный. @property (nonatomic)NSString *name;

сохранить: требуется, когда атрибут является указателем на метод сеттера object.The увеличит сохранить счетчик объекта, так что он будет занимать память в autorelease бассейна. @property (retain)NSString *name;

копия: Если вы используете копию, вы не можете использовать сохранить. Использование копии экземпляра класса будет содержать свою собственную копию. Даже если изменяемая строка устанавливаются и впоследствии изменена, экземпляр фиксирует любое значение оно имеет в то время он установлен. будет синтезирован Нет и присваивателя методы.

@property (copy) NSString *name;

NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];    
xyzObj.name = nameString;    
[nameString appendString:@"Pizza"];

только для чтения: Если вы не хотите, чтобы свойство быть изменено с помощью присваивателя, вы можете объявить свойство только для чтения. @property (readonly) NSString *name;

чтение и запись: это поведение по умолчанию. Вам не нужно указывать READWRITE атрибут в явном виде.

@property (readwrite) NSString *name;

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

@property (assign) NSInteger year;

сильный: замена для сохранения. @property (nonatomic, strong) AVPlayer *player;

unsafe_unretained: Есть несколько классов в какао и Cocoa Touch, которые пока не поддерживают слабые ссылки, а значит, вы не можете объявить слабое свойство или слабую локальную переменную, чтобы следить за ними. Эти классы включают NSTextView, NSFont и NSColorSpace и т.д.. Если вам нужно использовать слабую ссылку на один из этих классов, вы должны использовать небезопасные ссылки. Небезопасная ссылка похожа на нерабочую ссылку в том, что он не держит связанный с ним объект жив, но он не будет установлен в ноль, если объект назначения освобождаться.

@property (unsafe_unretained) NSObject *unsafeProperty;

Атомный свойство обеспечивает сохранение полностью инициализирован значение независимо от того, сколько нитей делают поглотитель & сеттер на нем.

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

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

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

Если вы используете атомарным, это означает, что поток будет безопасным и только для чтения. Если вы используете неатомическими, это означает, что несколько потоков доступ к переменным и нити небезопасна, но она выполняется быстро, сделала операции чтения и записи; это динамический тип.

Атомарность атомная (по умолчанию)

Атомный по умолчанию: если вы ничего не вводите, ваша собственность является атомарным. Атомное свойство гарантирует, что если вы пытаетесь читать из него, вы получите обратно действительное значение. Он не делает никаких гарантий относительно того, что может быть это значение, но вы получите обратно хорошие данные, а не только вредную память. То, что это позволяет сделать, если у вас есть несколько потоков или несколько процессов, указывающих на одной переменных, один поток может читать и другой поток может писать. Если они попали в то же время, читатель поток гарантированно получить один из двух значений: либо до изменения и после изменения. Что атомное не дает вам какие-либо рода гарантии, о которых из тех значений, которые вы могли бы получить. Атомный действительно часто путают с бытием потокобезопасной, и что не является правильным. Вы должны гарантировать вашу безопасность нить другие способы. Тем не менее, атомная будет гарантировать, что если вы пытаетесь прочитать, вы получите обратно какую-то ценность.

неатомической

На оборотной стороне, неатомический, как вы можете догадаться, просто означает, что «не делает этого атомарных вещи.» То, что вы потеряете то, что гарантирует, что вы всегда получите обратно что-то. Если вы пытаетесь прочитать в середине записи, вы можете получить обратно данные для мусора. Но, с другой стороны, вы идете немного быстрее. Поскольку атомные свойства должны сделать некоторую магию, чтобы гарантировать, что вы получите обратно значение, они немного медленнее. Если это свойство, что вы обращаетесь к много, вы можете упасть до неатомического, чтобы убедиться, что вы не подвергаясь, что скорость казни. Доступ

любезно https://academy.realm.io/posts/tmi-objective-c-property-attributes/

Атрибуты Атомарности собственности (атомные и неатомические) не отражены в соответствующей декларации Свифта собственности, но атомарность гарантия реализации Objective-C все еще держит, когда импортированные свойство доступно из Swift.

Так что - если определить атомную собственность в Objective-C будет оставаться атомными при использовании Свифта.

любезно https://medium.com/@YogevSitton/atomic-vs-non-atomic-properties-crash-course-d11c23f4366c

Атомные свойства : - Когда переменная присваивается с атомным свойством , что означает , что он имеет только один доступ потоков и будет поточно и будет хорошо в точки зрения производительности, будет иметь поведение по умолчанию.

Номера Атомные свойства : - Когда переменная присваивается с атомным свойством , что означает , что он имеет доступ с множеством потоков , и это не будет поточно и будет медленно точки зрения производительности, будет иметь поведение по умолчанию , а когда два разных потоков хотят получить доступ к переменной в то же время это даст неожиданные результаты.

Истина заключается в том, что они используют спин блокировку для реализации атомного свойства. Код, как показано ниже:

 static inline void reallySetProperty(id self, SEL _cmd, id newValue, 
      ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy) 
    {
        id oldValue;
        id *slot = (id*) ((char*)self + offset);

        if (copy) {
            newValue = [newValue copyWithZone:NULL];
        } else if (mutableCopy) {
            newValue = [newValue mutableCopyWithZone:NULL];
        } else {
            if (*slot == newValue) return;
            newValue = objc_retain(newValue);
        }

        if (!atomic) {
            oldValue = *slot;
            *slot = newValue;
        } else {
            spin_lock_t *slotlock = &PropertyLocks[GOODHASH(slot)];
            _spin_lock(slotlock);
            oldValue = *slot;
            *slot = newValue;        
            _spin_unlock(slotlock);
        }

        objc_release(oldValue);
    }

Чтобы упростить всю путаницу давайте понять блокировки мьютекса lock.Mutex в соответствии с именем запирает переменчивость в object.So если объект доступен классом нет другого класса может получить доступ к тому же object.In IOS @sychronise также обеспечивает взаимную блокировку lock.Now он служит в режиме FIFO и обеспечивает поток не зависит от двух классов, разделяющих один и тот же instance.However, если задача на основном поток, избегайте обращающегося объекта с использованием атомных свойств, как он может держать ваш пользовательский интерфейс и ухудшать производительность

Atomic: Обеспечить безопасность потоков путем блокировки нити при помощи NSLOCK.

Non атомное: Не обеспечить безопасность потоков, так как не существует механизма поточно-блокировки.