Qual é a diferença entre os atributos atômicas e não-atômicas?

https://stackoverflow.com/questions/588866

09-09-2019
|

Pergunta

O que fazer atomic e nonatomic média em declarações de propriedade?

@property(nonatomic, retain) UITextField *userName;
@property(atomic, retain) UITextField *userName;
@property(retain) UITextField *userName;

Qual é a diferença operacional entre estes três?

Solução

Os dois últimos são idênticos; "Atômica" é o comportamento padrão ( ~~note que não é realmente uma palavra-chave, que é especificado somente pela ausência de nonatomic~~ - atomic foi adicionado como uma palavra-chave nas versões recentes do llvm / clang).

Assumindo que você está @synthesizing as implementações do método, as mudanças vs. não-atômicos atômicos o código gerado. Se você estiver escrevendo seus próprios setter / getters, atômica / nonatomic / reter / atribuir / copiar são meramente consultivo. (Nota: @synthesize agora é o comportamento padrão nas versões recentes do LLVM Também não há necessidade de declarar variáveis ??de instância, pois eles vão ser sintetizados automaticamente, também, e terá um _ anexado ao seu nome para impedir o acesso direto acidental.).

Com "atômica", o setter sintetizado / getter irá garantir que um toda valor é sempre retornado do getter ou conjunto pela setter, independentemente da atividade setter em qualquer outro segmento. Ou seja, se thread A é no meio do getter enquanto segmento B chama o setter, um valor viável real - um objeto autoreleased, o mais provável -. Será devolvido para o chamador em A

Em nonatomic, sem tais garantias são feitas. Assim, nonatomic é consideravelmente mais rápido do que "atômica".

O que "atômica" faz não fazer é dar garantias sobre a segurança do thread. Se segmento A está a chamar o absorvente simultaneamente com a linha B e C chamando o passador com valores diferentes, segmento A pode obter qualquer um dos três valores devolvidos - a um antes de quaisquer formadores de ser chamado ou qualquer um dos valores passados ??para os formadores em B e C. do mesmo modo, o objecto pode acabar com o valor de B ou C, não há maneira de dizer.

Garantir a integridade dos dados - um dos principais desafios de programação multi-threaded -. É alcançado por outros meios

Adicionando a isto:

atomicity de uma única propriedade também não pode segurança do thread garantia quando várias propriedades dependentes estão em jogo.

Considere o seguinte:

 @property(atomic, copy) NSString *firstName;
 @property(atomic, copy) NSString *lastName;
 @property(readonly, atomic, copy) NSString *fullName;

Neste caso, passe Uma poderia ser mudar o nome do objeto chamando setFirstName: e, em seguida, chamando setLastName:. Nesse meio tempo, linha B pode chamar fullName entre duas chamadas fio de A e vai receber o novo primeiro nome juntamente com o antigo sobrenome.

Para resolver isso, você precisa de um modelo transacional . Ou seja, algum outro tipo de sincronização e / ou exclusão que permite excluir o acesso a fullName enquanto as propriedades dependentes estão sendo atualizados.

Outras dicas

Isto é explicado na documentação da Apple , mas abaixo estão alguns exemplos do que está realmente acontecendo. Note que não há nenhuma palavra-chave "atômica", se você não especificar "nonatomic", em seguida, a propriedade é atômica, mas especificando "atômica" explicitamente irá resultar em um erro.

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

- (UITextField *) userName {
    return userName;
}

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

Agora, a variante atômica é um pouco mais complicado:

//@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_;
    }
}

Basicamente, a versão atômica tem de ter um bloqueio, a fim de garantir segurança de segmentos, e também está batendo a contagem ref sobre o objeto (e a contagem de disparo automático para equilibrá-lo) para que o objeto é garantida a existir para o chamador , caso contrário, há uma condição de corrida potencial se outro segmento está definindo o valor, fazendo com que a contagem de referência a cair para 0.

Há realmente um grande número de variantes diferentes de como essas coisas funcionam, dependendo se as propriedades são valores escalares ou objetos, e como reter, copiar, somente leitura, não atômica, etc interagem. Em geral, os sintetizadores de propriedade só sei como fazer a "coisa certa" para todas as combinações.

Atomic

é o comportamento padrão
irá garantir o actual processo é completado pela CPU, antes de outro processo acessa a variável
não é rápido, pois garante o processo for concluído inteiramente

Não-Atomic

Não é o comportamento padrão
mais rápido (para código sintetizado, ou seja, para as variáveis ??criadas usando @property e @synthesize)
não thread-safe
pode resultar em um comportamento inesperado, quando dois acessos processo diferente a mesma variável ao mesmo tempo

A melhor maneira de entender a diferença está usando o exemplo a seguir.

Suponha que há uma propriedade de cadeia atômica chamado "nome", e se você chamar [self setName:@"A"] a partir de fios A, [self setName:@"B"] chamada de segmento B, e [self name] chamada de segmento C, em seguida, todas as operações sobre diferentes tópicos será realizada em série que significa que se um segmento está executando um setter ou getter, então outros tópicos vai esperar.

Isso faz com propriedade "nome" de leitura / gravação segura, mas se outro segmento, D, chamadas [name release] simultaneamente, em seguida, esta operação pode produzir um acidente, porque não há nenhuma chamada setter / getter envolvido aqui. O que significa que um objeto é leitura / gravação segura (ATOMIC), mas não thread-safe como outros tópicos pode enviar simultaneamente qualquer tipo de mensagens para o objeto. O desenvolvedor deve garantir thread-segurança para tais objetos.

Se o "nome" propriedade foi nonatomic, em seguida, todos os segmentos no exemplo acima - A, B, C e D executará produzindo simultaneamente qualquer resultado imprevisível. Em caso de atómica, qualquer um de A, B ou C será executado em primeiro lugar, mas D pode ainda ser executadas em paralelo.

A sintaxe e semântica são já bem definida por outros excelentes respostas para essa pergunta. Porque execução e desempenho não são detalhadas bem, vou acrescentar a minha resposta.

Qual é a diferença funcional entre estes 3?

Eu sempre considerada atômica como um padrão bastante curioso. Ao nível de abstração, trabalhamos em usar propriedades atômicas para uma classe como um veículo para atingir 100% de fios de segurança é um caso esquina. Para programas multithread verdadeiramente corretas, a intervenção do programador é quase certamente uma exigência. Enquanto isso, as características de desempenho e execução ainda não foram detalhados em profundidade. Tendo escrito alguns programas fortemente com vários segmentos ao longo dos anos, eu tinha sido declarando minhas propriedades como nonatomic todo o tempo, porque atômica não foi sensível para qualquer finalidade. Durante a discussão dos detalhes de propriedades atômicas e não-atômicas esta pergunta , eu fiz algumas profiling encontrou alguns resultados curiosos.

Execução

Ok. A primeira coisa que eu gostaria de esclarecer é que a implementação de bloqueio é e abstraída definido pela implementação. Louis usa @synchronized(self) no seu exemplo - Eu já vi isso como uma fonte comum de confusão. A implementação não realmente uso @synchronized(self); ele usa nível de objeto bloqueios de rotação . A ilustração de Louis é bom para uma ilustração de alto nível usando construções todos estamos familiarizados com, mas é importante saber que não usa @synchronized(self).

Outra diferença é que as propriedades atômicas reterá / ciclo de lançamento de seus objetos dentro do getter.

Desempenho

Aqui está a parte interessante: Performance usando a propriedade atômica acessos em incontestável (por exemplo, single-threaded) casos pode ser realmente muito rápido em alguns casos. Em menos de ideal casos, o uso de acessos atômicas pode custar mais de 20 vezes a sobrecarga de nonatomic. Enquanto o Contested caso usando 7 fios era 44 vezes mais lentos para a estrutura de três bytes (2,2 GHz core i7 Quad-core, x86_64). A estrutura de três bytes é um exemplo de uma propriedade muito lento.

nota lateral interessante: acessores definidos pelo usuário do struct de três bytes eram 52 vezes mais rápido do que os acessores atômicas sintetizados; ou 84% a velocidade de assessores não-atômicas sintetizados.

Objetos em casos contestados também pode exceder 50 vezes.

Devido ao número de otimizações e variações nas implementações, é muito difícil medir os impactos reais nestes contextos. Você pode ouvir muitas vezes algo como "Confiança-lo a menos que você perfil e achar que é um problema". Devido ao nível de abstração, é realmente muito difícil medir o impacto real. Recolhendo os custos reais de perfis pode ser muito demorado, e devido a abstrações, bastante impreciso. Bem, ARC vs MRC pode fazer uma grande diferença.

Então vamos passo para trás, não centrando-se sobre a implementação de acessos de propriedade, vamos incluir os suspeitos do costume como objc_msgSend, e examinar alguns reais resultados de alto nível para muitas chamadas para um NSString getter em incontestável casos (valores em segundos):

MRC | nonatomic | getters implementadas manualmente: 2
MRC | nonatomic | getter sintetizado: 7
MRC | atômica | getter sintetizado: 47
ARC | nonatomic | getter sintetizado: 38 (nota: ARC da adição de ref contagem de ciclismo aqui)
ARC | atômica | getter sintetizado: 47

Como você provavelmente já adivinhou, atividade contagem de referência / ciclismo é um contribuinte significativo com atomics e sob ARC. Você também veria greater diferenças em casos contestados.

Apesar de eu prestar muita atenção ao desempenho, eu continuo a dizer Semântica primeiramente! . Enquanto isso, o desempenho é uma prioridade baixa para muitos projetos. No entanto, sabendo os detalhes de execução e os custos de tecnologias que você usa certamente não faz mal. Você deve usar a tecnologia certa para as suas necessidades, objetivos e habilidades. Felizmente, isso vai lhe poupar algumas horas de comparações, e ajudá-lo a tomar uma decisão mais bem informada ao projetar seus programas.

Atomic = segurança do thread

Não-atômica = Sem segurança do thread

Segmento de segurança:

As variáveis ??de instância são thread-safe se comportar corretamente quando acessado de vários segmentos, independentemente do agendamento ou intercalação da execução desses tópicos pelo ambiente de tempo de execução, e sem qualquer sincronização adicional ou de coordenação por parte da vocação código.

Em nosso contexto:

Se um segmento altera o valor da instância o valor alterado é acessível a todos os segmentos, e apenas um thread pode alterar o valor de cada vez.

Onde uso `atomic`:

Se a variável de instância é que vai ser acessado em um ambiente multithread.

Implicação de `atomic`:

Não tão rápido como nonatomic porque nonatomic não requer qualquer trabalho de vigilância em que a partir de tempo de execução.

Onde uso `nonatomic`:

Se a variável de instância não vai ser alterada por vários segmentos que você pode usá-lo. Além disso, melhora o desempenho.

Eu encontrei uma explicação muito bem colocado de propriedades atômicas e não atômicas aqui . Aqui está algum texto relevante do mesmo:

significa 'atômicas' não pode ser dividido. Em OS / programação termos uma chamada de função atômica é aquele que não pode ser interrompido - toda a função deve ser executada, e não trocados da CPU por troca de contexto habitual do OS até que esteja completo. Apenas no caso de você não sabia: uma vez que a CPU só pode fazer uma coisa de cada vez, gira OS acesso ao CPU a todos os processos em execução em pouco tempo-fatias, para dar o ilusão de multitarefa. O programador CPU pode (e faz) interromper um processo em qualquer ponto na sua execução - mesmo em chamada de função mid. Assim, para ações como atualização compartilhada variáveis ??de contador, onde dois processos poderia tentar atualizar a variável ao mesmo tempo, eles devem ser executados 'atomicamente', ou seja, cada ação de atualização tem que terminar em sua totalidade antes de qualquer outro processo pode ser trocado para o CPU.

Então eu estaria supondo que atômica, neste caso, os métodos leitor atributo não pode ser interrompido - em vigor significado que a variável (s) a ser lido pelo método não pode mudar a sua metade do caminho valor através porque algum outro thread / chamada / função é trocado para o CPU.

Porque as variáveis ??atomic não pode ser interrompido, o valor contido por eles em qualquer ponto é (thread-lock) a garantia de ser incorrupto , embora, assegurando deste bloqueio de segmento torna o acesso a eles mais lento. variáveis ??non-atomic, por outro lado, não fazem tal garantia, mas não oferecem o luxo de um acesso mais rápido. Para resumir, ir com non-atomic quando você sabe suas variáveis ??não serão acessados ??por múltiplos threads simultaneamente e acelerar as coisas.

Depois de ler tantos artigos, mensagens de estouro de pilha e fazendo demonstração aplicações para verificar atributos de propriedade variáveis, eu decidi colocar todos os atributos informações juntos:

atomic // Padrão
nonatomic
strong = retain // Padrão
weak = unsafe_unretained
retain
assign // Padrão
unsafe_unretained
copy
readonly
readwrite // Padrão

No artigo atributos de propriedade variável ou modificadores em iOS você pode encontrar todos os atributos acima mencionados, e que vai certamente ajudá-lo.

atomic
- meios atomic apenas um acesso rosca variável (tipo estático).
- atomic é thread-safe.
- Mas é lento no desempenho
- atomic é o comportamento padrão
- Atomic acessores em um ambiente não lixo coletado (ou seja, quando se utiliza reter / release / disparo automático) vai usar um bloqueio para garantir que outro segmento não interfere com a configuração correta / obtenção do valor.
- Não é realmente uma palavra-chave.
Exemplo:
```
    @property (retain) NSString *name;

    @synthesize name;
```
nonatomic
- meios nonatomic acesso rosca múltipla a variável (tipo dinâmico).
- nonatomic é thread-inseguro.
- Mas é rápido no desempenho
- nonatomic não é um comportamento padrão. Nós precisamos adicionar a palavra-chave nonatomic no atributo propriedade.
- Pode resultar em um comportamento inesperado, quando dois acessos diferentes processos (threads) a mesma variável ao mesmo tempo.
Exemplo:
```
    @property (nonatomic, retain) NSString *name;

    @synthesize name;
```

Atomic:

Atomic garante que o acesso à propriedade será executada de uma maneira atômica. Por exemplo. sempre retornar um objetos totalmente inicializado, qualquer get / set de uma propriedade em um segmento deve completar antes que outra possa acessá-lo.

Se você imaginar a seguinte função que ocorre em dois threads ao mesmo tempo você pode ver porque os resultados não seria bonito.

-(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;
  }

  ...
}

Pros: Restituição de bens totalmente inicializado cada vez que faz com que seja melhor escolha em caso de multi-threading.

Contras: acerto de desempenho, torna a execução um pouco mais lento

Não-Atomic:

Ao contrário Atómica, não garante retorno objeto totalmente inicializado cada vez.

Pros: execução extremamente rápida.

Contras: Chances de valor de lixo em caso de multi-threading.

resposta mais fácil primeira: Não há nenhuma diferença entre seu segundo dois exemplos. Por padrão, os assessores da propriedade são atômicas.

Atomic acessores em um ambiente não lixo coletado (ou seja, quando se utiliza reter / release / disparo automático) vai usar um bloqueio para garantir que outro segmento não interfere com a configuração correta / obtenção do valor.

Veja a " Desempenho e Enfiar " do Objective C-documentação da Apple 2.0 para mais algumas informações e para outras considerações ao criar aplicativos multi-threaded.

Atomic significa apenas uma thread acessa a variável (tipo estático). Atomic é thread-safe, mas é lento.

significa que não atômica vários segmentos acessar a variável (tipo dinâmico). Atômica é thread-seguro, mas é rápido.

Atomic é segmento seguro , é lento e bem-assegura (não garantida) que apenas o valor bloqueado é fornecido não importa quantos threads estão tentando o acesso através da mesma zona. Ao usar atômica, um pedaço de código escrito dentro dessa função torna-se parte da seção crítica, a que apenas um thread pode executar ao mesmo tempo.

Ele só garante a segurança do segmento; ele não garante isso. O que quero dizer é que você contratar um motorista especialista para você carro, ainda não garante carro não vai atender a um acidente. No entanto, a probabilidade continua a ser o mais leve.

Atomic - não pode ser dividido, então o resultado é esperado. Com nonatomic -. Quando outro segmento de acesso a zona de memória que pode modificá-la, de modo que o resultado é inesperado

Código Discussão:

Atomic make getter e setter do segmento seguro propriedade. por exemplo, se u ter escrito:

self.myProperty = value;

é thread-safe.

[myArray addObject:@"Abc"]

não é thread-safe.

Não existe tal palavra-chave "atômica"

@property(atomic, retain) UITextField *userName;

Podemos usar o acima como

@property(retain) UITextField *userName;

questão See Stack Overflow estou recebendo problemas se eu usar @property (atômica, reter) NSString * myString .

O padrão é atomic, isso significa que ele custa-lhe um desempenho sempre que você usar a propriedade, mas é thread-safe. O Objective-C faz, é definido um bloqueio, portanto, apenas o segmento real pode acessar a variável, enquanto o setter / getter é executado.

Exemplo com MRC de uma propriedade, com um _INTERNAL ivar:

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

Assim, estes dois últimos são os mesmos:

@property(atomic, retain) UITextField *userName;

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

Por outro lado faz nonatomic nada acrescentam ao seu código. Por isso, só é thread-safe se você mecanismo de segurança código você mesmo.

@property(nonatomic, retain) UITextField *userName;

As palavras-chave não tem que ser escrito como primeiro atributo propriedade em tudo.

Não se esqueça, isso não significa que a propriedade como um todo é thread-safe. Apenas a chamada de método do setter / getter é. Mas se você usar um setter e depois que um getter, ao mesmo tempo com 2 fios diferentes, ele poderia ser quebrado também!

atômica (padrão)

Atomic é o padrão: se você não digitar nada, sua propriedade é atômica. Uma propriedade atômica é garantido que se você tentar ler a partir de -lo, você receberá de volta um valor válido. Isso não faz quaisquer garantias sobre o que esse valor poderia ser, mas você vai voltar bons dados, não memória junk apenas. O que isto permite que você faça é se você tiver múltiplas fios ou vários processos que apontam em uma única variável, uma thread pode ler e outro segmento pode escrever. Se eles batem ao mesmo tempo, o fio leitor é garantido para obter um dos dois valores: quer antes da mudança ou após a mudança. O atômica não dar-lhe algum tipo de garantia sobre qual desses valores pode obter. Atomic é realmente comumente confundido com ser thread-safe, e que não é correto. Você precisa garantir a sua segurança do thread outras maneiras. No entanto, a garantia vontade atômica que se você tentar ler, você recebe de volta algum tipo de valor.

nonatomic

No outro lado, não atômicos, como você provavelmente pode imaginar, os meios apenas, “Não faça esse material atômico.” O que você perde é que garantia de que você sempre voltar algo. Se você tenta ler no meio de um gravação, você pode voltar dados de lixo. Mas, por outro lado, você vai um pouco mais rápido. Como as propriedades atômicas tem que fazer alguma mágica a garantia de que você vai receber de volta um valor, eles são um pouco mais lento. E se é uma propriedade que você está acessando um lote, você pode querer deixar cair até nonatomic para se certificar de que você não está incorrer em que a velocidade penalidade.

Veja mais aqui: https://realm.io/news/tmi-objective-c- propriedade-atributos /

Se você estiver usando sua propriedade no código de multi-threaded, então você seria capaz de ver a diferença entre os atributos não-atômicas e nucleares. Nonatomic é mais rápido do que atômico e atômico é thread-safe, não nonatomic.

Vijayendra Tripathi já dado um exemplo de um ambiente multi-threaded.

meio -Atomic apenas um acesso rosca variável (tipo estático).
-Atomic é thread-safe.
-mas é lento no desempenho

Como declarar:

Como atômica é padrão, então,

@property (retain) NSString *name;

E no arquivo de implementação

self.name = @"sourov";

Suponha que uma tarefa relacionada a três propriedades são

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

Todas as propriedades trabalhar paralelamente (como de forma assíncrona).

Se você chamar "nome" a partir de fios A ,

Ao mesmo tempo, se você chamar

[self setName:@"Datta"]

a partir de fios B ,

Agora Se a propriedade * nome é nonatomic seguida

Ele irá retornar o valor "Datta" para A
Ele irá retornar o valor "Datta" para B

É por isso que não atômica é chamado fio insegura Mas, mas é rápido no desempenho por causa da execução paralela

Agora Se a propriedade * nome é atômica

Vai garantir valor "Sourov" para A
Em seguida, ele irá retornar o valor "Datta" para B

É por isso atômica é chamado segmento seguro e É por isso que é chamado de leitura e escrita segura

Esta operação situação irá realizar em série. e lento no desempenho

-. Meio nonatomic acesso rosca múltipla a variável (tipo dinâmico)

-. Atômica é o segmento inseguro

- mas é rápido no desempenho

-Nonatomic não é um comportamento padrão, precisamos adicionar palavra-chave nonatomic no atributo propriedade.

Para Em Swift Confirmando que as propriedades Swift são nonatomic no sentido ObjC. Uma das razões é assim que você pensa sobre se por propriedade atomicidade é suficiente para suas necessidades.

Referência: https://forums.developer.apple.com/thread/25642

Fro mais informações, visite o site http://rdcworld-iphone.blogspot.in/ 2012/12 / variável de propriedade-atributos-or.html

Antes de começar: Você deve saber que cada objeto na memória precisa ser desalocada de memória para um novo escritor para acontecer. Você não pode simplesmente escrever em cima de algo que você faz no papel. Você deve primeira apagar (dealloc)-lo e, em seguida, você pode escrever para ele. Se no momento em que o apagamento é feito (ou metade feito) e nada ainda não foi escreveu (ou metade escreveu) e você tenta ler poderia ser muito problemático! Atômica e ajuda nonatomic você tratar este problema de diferentes maneiras.

Primeiro leia esta questão e depois ler resposta de Bbum. Além disso, em seguida, ler o meu resumo.

atomic sempre garante

Se duas pessoas diferentes querem ler e escrever ao mesmo tempo, o seu papel não só vai queimar! -.> Seu aplicativo nunca irá falhar, mesmo em uma condição de corrida
Se uma pessoa está tentando escrever e só tem escrito 4 dos 8 letras para escrever, então não pode ler no meio, a leitura só pode ser feito quando todos os 8 letras é escrito -> Sem ler (get) vai acontecer em 'um segmento que ainda está escrevendo', ou seja, se há 8 bytes para bytes a serem escritos, e apenas 4 bytes são escritos - até aquele momento, você não tem permissão para ler a partir dele. Mas desde que eu disse que não vai falhar, então seria lido a partir do valor de um autoreleased objeto.
Se antes escrevendo Have apagado o que foi escrito anteriormente em papel e então alguém quer ler você pode ainda ler. Como? Você vai ser a leitura de algo semelhante ao Mac OS bin Trash (não como bin lixo é ainda 100% apagados ... ele está em um limbo) ---> Se ThreadA é para ler enquanto ThreadB já desalocadas para escrever, você obteria um valor a partir de qualquer valor final totalmente escrito por ThreadB ou obter algo de piscina disparo automático.

Reter conta são a maneira em que a memória é gerido em Objective-C. Quando você cria um objeto, ele tem um manter a contagem de 1. Quando você envia um objeto a reter mensagem, a sua manter a contagem é incrementado por 1. Quando você envia um objeto uma mensagem de liberação, o seu reter contagem é diminuída em 1. Quando você envia um objeto uma mensagem de disparo automático , a sua contagem de reter é decrementado em um, em algum momento no futuro. Se um object's reter contagem é reduzido a 0, ele é desalocada.

Atomic não segurança de segmentos garantia, mas é útil para alcançar a segurança do thread. Thread-safe é relativo a como você escrever seu código / qual segmento a fila que você está lendo / escrevendo a partir. Ele só garante multithreading não crashable.

O que ?! São multithreading e diferente?

Sim. meios multithreading: vários segmentos pode ler um pedaço compartilhada de dados ao mesmo tempo e não vamos falhar, mas ele não garante que você não está lendo a partir de um valor não-autoreleased. Com a segurança do thread, é garantido que o que você lê não é lançado auto. A razão por que não fazemos tudo atômica por padrão é que existe um custo de desempenho e para a maioria das coisas realmente não precisa de segurança do thread. Algumas partes da nossa necessidade de código-lo e para aquelas poucas peças, precisamos escrever nosso código de uma forma thread-safe usando bloqueios, mutex ou sincronização.

nonatomic

Uma vez que não existe tal coisa como Mac OS Trash Bin, então ninguém se importa se ou não você sempre terá um valor (<- Isso poderia potencialmente levar a um acidente), nem cuidados ninguém, se alguém tenta ler a meio caminho através de seu escrever (embora metade escrevendo em memory é muito diferente da escrita na metade no papel, na memória poderia dar-lhe um valor estúpida louca de antes, enquanto em papel só ver metade do que foi escrito) -> não garante a não falhar, porque ele doesn' t usar mecanismo de disparo automático.
não garante valores escritos completos para ser lido!
É mais rápido do que atômico

Em geral eles são diferentes em 2 aspectos:

Crashing ou não por causa de ter ou não ter uma piscina disparo automático.
Permitindo a ser lido bem no meio de um 'ainda não escrita acabado ou valor vazio' ou não permitir e permitindo apenas a ler quando o valor é totalmente escrita.

Os garante propriedades atômicas para reter um valor totalmente inicializado, independentemente de quantos threads estão fazendo getter e setter nele.

Os especifica de propriedade não-atômicas que assessores sintetizados simplesmente definir ou devolver um valor diretamente, sem garantias sobre o que acontece se esse mesmo valor é acessado simultaneamente a partir de diferentes tópicos.

Atomic significa apenas uma thread pode acessar a variável em um (tipo estático) tempo. Atomic é thread-safe, mas é lento.

meios nonatomic vários segmentos pode acessar a variável ao mesmo tempo (tipo dinâmico). Atômica é thread-seguro, mas é rápido.

Atomicity atômica (padrão)

Atomic é o padrão: se você não digitar nada, sua propriedade é atômica. Uma propriedade atômica é garantido que se você tentar ler a partir de -lo, você receberá de volta um valor válido. Isso não faz quaisquer garantias sobre o que esse valor poderia ser, mas você vai voltar bons dados, não memória junk apenas. O que isto permite que você faça é se você tiver múltiplas fios ou vários processos que apontam em uma única variável, uma thread pode ler e outro segmento pode escrever. Se eles batem ao mesmo tempo, o fio leitor é garantido para obter um dos dois valores: quer antes da mudança ou após a mudança. O atômica não dar-lhe algum tipo de garantia sobre qual desses valores pode obter. Atomic é realmente comumente confundido com ser thread-safe, e que não é correto. Você precisa garantir a sua segurança do thread outras maneiras. No entanto, a garantia vontade atômica que se você tentar ler, você recebe de volta algum tipo de valor.

nonatomic

No outro lado, não atômicos, como você provavelmente pode imaginar, os meios apenas, “Não faça esse material atômico.” O que você perde é que garantia de que você sempre voltar algo. Se você tenta ler no meio de um gravação, você pode voltar dados de lixo. Mas, por outro lado, você vai um pouco mais rápido. Como as propriedades atômicas tem que fazer alguma mágica a garantia de que você vai receber de volta um valor, eles são um pouco mais lento. E se é uma propriedade que você está acessando um lote, você pode querer deixar cair até nonatomic para se certificar de que você não está incorrer em que a velocidade pena. Acesso

https://academy.realm.io/posts / TMI-Objective-C-propriedade-atributos /

atributos Atomicidade de propriedade (atômicas e não-atômicas) não são refletidas no correspondente Swift declaração de propriedade, mas as garantias atomicidade da implementação Objective-C ainda mantêm quando a propriedade importado é acessado a partir Swift.

Então -. Se você definir uma propriedade atômica em Objective-C permanecerá atômica quando usado por Swift

cortesia https://medium.com/@YogevSitton/ atômico-vs-não-atômicos-properties-crash-course-d11c23f4366c

Se você estiver usando atômica, isso significa que o segmento vai ser seguro e somente leitura. Se você estiver usando nonatomic, isso significa que os vários segmentos acessar a variável e é o segmento inseguro, mas é executado rápido, feito uma leitura e gravação operações; este é um tipo dinâmico.

A verdade é que eles usam bloqueio de rotação para implementar propriedade atômica. O código abaixo:

 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);
    }

Propriedades atômicas : -. Quando uma variável atribuída à propriedade atômica que significa que ele tem apenas um acesso de linha e vai ser segmento seguro e vai ser bom na perspectiva de desempenho, terá comportamento padrão

Propriedades não Atomic : - Quando uma variável atribuída à propriedade atômica que significa que tem acesso multi fio e não vai ser segmento seguro e será lenta na perspectiva de desempenho, terá comportamento padrão e quando dois tópicos diferentes quer variável de acesso ao mesmo tempo que lhe dará resultados inesperados.

Para simplificar toda a confusão, vamos entender bloqueio mutex.

bloqueio Mutex, conforme o nome, bloqueia a mutabilidade do objecto. Portanto, se o objeto é acessado por uma classe, nenhuma outra classe pode acessar o mesmo objeto.

iOS, @sychronise também proporciona o bloqueio de exclusão mútua .agora que serve no modo FIFO e assegura o escoamento não é afectada por duas classes que partilham o mesmo exemplo. No entanto, se a tarefa está no segmento principal, evite acessar objeto usando propriedades atômicas que possa realizar o seu UI e degradar o desempenho.

Atomic:. Certifique-thread-segurança, bloqueando o segmento usando NSLOCK

Não atômica:. Não garante thread-segurança, não há nenhum mecanismo de bloqueio de rosca

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow