atomic和nonatomic区别

atomic

• 默认为atomic，原子性的(最小单位)，表示线程安全的，在多线程中，其保证了setter和getter方法的线程安全，保证其读写的完整性，其结果状态可预见的。

• 当其被一个线程使用时，其中用到了自旋锁（自旋锁: 为实现保护共享资源而提出一种锁机制。在任何时刻，最多只能有一个保持者; 在任何时刻, 最多只能有一个执行单元获得锁）。所以在任何时刻，最多只有一个线程读或写。

• 消耗系统资源 。使用任何锁都需要消耗系统资源（内存资源和CPU时间) :
  1.建立锁所需要的资源
  2.当线程被阻塞时所需要的资源

• atomic关键词下表现也并非是绝对线程安全的。因为其只保证setter和getter的读写安全，其它方法并不能保证。

  例1：@property(atomic,strong)NSMutableArray *arrM;
  如果一个线程循环的读数据，一个线程循环写数据，那么肯定会产生内存问题，这和setter、getter没有关系，但其表现出线程不安全。如使用[self.arr objectAtIndex:index]也不是线程安全的。

  例2：如果线程 A 调了 getter，与此同时线程 B 、线程 C 都调了 setter——那最后线程 A get 到的值，3种都有可能：可能是 B、C set 之前原始的值，也可能是 B set 的值，也可能是 C set 的值。同时，最终这个属性的值，可能是 B set 的值，也有可能是 C set 的值。
  这个例子实际并不能说明atomic下的setter和getter不安全的情况，虽说其结果是不可预见的，但在这里的三个线程的同时执行，其并非同时执行getter和setter方法。因为ABC线程是无序的，所以出现的结果也不固定。 但可以看出它的读写依然是完整的。

   #import <Foundation/Foundation.h>
  
  @interface Person : NSObject
  @property (copy) NSString *name;
  @end
  

NSOperationQueue并发执行

    Person *person = [Person new];

    NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];
    operationQueue.maxConcurrentOperationCount = 3;
    NSLog(@"start");
    [operationQueue addOperationWithBlock:^{
        NSLog(@"任务A %@",[NSThread currentThread]);
        NSLog(@"A线程get %@",person.name);
    }];
    [operationQueue addOperationWithBlock:^{
        NSLog(@"任务B %@",[NSThread currentThread]);
        [person setName:@"nameB"];
    }];
    [operationQueue addOperationWithBlock:^{
        NSLog(@"任务C %@",[NSThread currentThread]);
        [person setName:@"nameC"];
    }];
    NSLog(@"end");

打印：

    2018-05-03 02:06:23.352443+0800 OC基础[6816:351888] start
    2018-05-03 02:06:23.352970+0800 OC基础[6816:351888] end
    2018-05-03 02:06:23.353090+0800 OC基础[6816:351933] 任务B <NSThread: 0x604000277bc0>{number = 4, name = (null)}
    2018-05-03 02:06:23.353107+0800 OC基础[6816:351936] 任务C <NSThread: 0x600000467080>{number = 5, name = (null)}
    2018-05-03 02:06:23.353108+0800 OC基础[6816:351935] 任务A <NSThread: 0x604000277e00>{number = 3, name = (null)}
    2018-05-03 02:06:23.353438+0800 OC基础[6816:351935] A线程get nameC

DCD并发执行

    Person *person = [Person new];

    dispatch_queue_t dispatchQueue = dispatch_queue_create("fyj.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t dispatchGroup = dispatch_group_create();
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务A %@",[NSThread currentThread]);
        NSLog(@"%@",person.name);
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务B %@",[NSThread currentThread]);
        [person setName:@"nameB"];
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务C %@",[NSThread currentThread]);
        [person setName:@"nameC"];
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务D %@",[NSThread currentThread]);
    });
    dispatch_group_notify(dispatchGroup, dispatch_get_main_queue(), ^(){
        NSLog(@"end");
    });

打印：

    2018-05-03 02:40:45.786005+0800 OC基础[7110:370410] 任务C <NSThread: 0x600000276a80>{number = 5, name = (null)}
    2018-05-03 02:40:45.786006+0800 OC基础[7110:370408] 任务D <NSThread: 0x604000462680>{number = 6, name = (null)}
    2018-05-03 02:40:45.786005+0800 OC基础[7110:370407] 任务B <NSThread: 0x604000462600>{number = 4, name = (null)}
    2018-05-03 02:40:45.786047+0800 OC基础[7110:370409] 任务A <NSThread: 0x604000462640>{number = 3, name = (null)}
    2018-05-03 02:40:45.786339+0800 OC基础[7110:370409] nameB
    2018-05-03 02:40:45.801127+0800 OC基础[7110:370367] end

可以看出，只要知道线程的顺序，也可以预见get到的值 — get获取到其之前的线程最后一次set的值，若其之前没有线程set值，则get到的为null。所以网上的这个例子并不能说明了atomic的读写是不安全的。

再举个atomic的读写是不安全的例子：
例3：

  @property (atomic, assign) int number;

    dispatch_apply(100000, dispatch_get_global_queue(0, 0), ^(size_t index) {
        self.number++;
    });
    NSLog(@"%d",self.number);

如果安全，打印出的应该是100000，但实际却不是；这用的atomic，却表现出线程不安全。
为什么呢？因为它里面self.number++相当于int temp = self.number + 1;self.number = temp; 所以这说明多线程中atomic对两个setter的操作是不能保证线程不安全的。

nonatomic

• 非原子的，在多线程中，其setter和getter操作是不安全的。

• 因为其读写没有加锁，所以nonatomic会比atomic的运行速度快。

   #import <Foundation/Foundation.h>
  
  @interface Person : NSObject
  @property (nonatomic, copy) NSString *name;
  @end
  

GCD并发执行

    Person *person = [Person new];

    dispatch_queue_t dispatchQueue = dispatch_queue_create("fyj.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t dispatchGroup = dispatch_group_create();
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务A %@",[NSThread currentThread]);
        NSLog(@"%@",person.name);
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务B %@",[NSThread currentThread]);
        [person setName:@"nameB"];
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务C %@",[NSThread currentThread]);
        [person setName:@"nameC"];
    });
    dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
        NSLog(@"任务D %@",[NSThread currentThread]);
    });
    dispatch_group_notify(dispatchGroup, dispatch_get_main_queue(), ^(){
        NSLog(@"end");
    });

打印：

    2018-05-03 03:05:35.839568+0800 OC基础[7330:384401] 任务D <NSThread: 0x600000475540>{number = 6, name = (null)}
    2018-05-03 03:05:35.839568+0800 OC基础[7330:384403] 任务B <NSThread: 0x600000475480>{number = 4, name = (null)}
    2018-05-03 03:05:35.839568+0800 OC基础[7330:384402] 任务C <NSThread: 0x604000276c00>{number = 5, name = (null)}
    2018-05-03 03:05:35.839609+0800 OC基础[7330:384400] 任务A <NSThread: 0x604000276cc0>{number = 3, name = (null)}
    2018-05-03 03:05:35.839858+0800 OC基础[7330:384400] nameB
    2018-05-03 03:05:35.853579+0800 OC基础[7330:384371] end

此时根本不能预见get到的值。所以nonatomic在多线程下的setter和getter的操作是线程不安全的。

参考：
https://blog.csdn.net/freeelinux/article/details/53695111
https://stackoverflow.com/questions/588866/whats-the-difference-between-the-atomic-and-nonatomic-attributes
http://www.cocoachina.com/bbs/read.php?tid=1720812
https://blog.csdn.net/chenyufeng1991/article/details/49687215