1、程安全隐患

当多个线程同时访问一块资源时，很容易产生数据错乱和数据安全问题，比如多个线程读取/写入同一个对象、同一个变量、同一个文件等。

2、问题举例

2.1、存钱取钱问题

当多条线程同时进行存钱、取钱行为，就会出现余额不正确的问题，如图所示：
image.png

  1. - (void)moneyTest {
  3.     self.money = 500;
  5.     dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
  7.     // 每次存入50，存10次，共500快
  8.     dispatch_async(queue, ^{
  9.         for (int i = 0; i < 10; i++) {
  10.             [self saveMoney];
  11.         }
  12.     });
  14.     // 每次取出20，存10次，共200快
  15.     dispatch_async(queue, ^{
  16.         for (int i = 0; i < 10; i++) {
  17.             [self drawMoney];
  18.         }
  19.     });
  20. }
  22. - (void)saveMoney {
  23.     int oldMoney = self.money;
  24.     sleep(.2);
  25.     oldMoney += 50;
  26.     self.money = oldMoney;
  27.     NSLog(@"存入50还剩%d元",self.money);
  28. }
  30. - (void)drawMoney {
  31.     int oldMoney = self.money;
  32.     sleep(.2);
  33.     oldMoney -= 20;
  34.     self.money = oldMoney;
  35.     NSLog(@"取出20还剩%d元",self.money);
  36. }

打印结果：

  1. ～: 取出20还剩480元
  2. ～: 存入50还剩550元
  3. ～: 取出20还剩530元
  4. ～: 存入50还剩580元
  5. ～: 取出20还剩560元
  6. ～: 存入50还剩610元
  7. ～: 取出20还剩590元
  8. ～: 存入50还剩640元
  9. ～: 取出20还剩620元
  10. ～: 存入50还剩670元
  11. ～: 取出20还剩650元
  12. ～: 存入50还剩700元
  13. ～: 取出20还剩680元
  14. ～: 存入50还剩730元
  15. ～: 取出20还剩710元
  16. ～: 存入50还剩760元
  17. ～: 取出20还剩740元
  18. ～: 存入50还剩790元
  19. ～: 取出20还剩770元
  20. ～: 存入50还剩820元

期望剩余应该是 500 + 500 - 200 = 800元。

2.2、卖票问题

当多条线程同时进行卖票操作时，就会出现余票不正确问题，如图所示：
image.png

  1. - (void)saleTickets {
  3.     self.ticketsCount = 15;
  5.     dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
  7.     dispatch_async(queue, ^{
  8.         for (int i = 0; i < 5; i++) {
  9.             [self saleTicket];
  10.         }
  11.     });
  13.     dispatch_async(queue, ^{
  14.         for (int i = 0; i < 5; i++) {
  15.             [self saleTicket];
  16.         }
  17.     });
  19.     dispatch_async(queue, ^{
  20.         for (int i = 0; i < 5; i++) {
  21.             [self saleTicket];
  22.         }
  23.     });
  24. }
  26. - (void)saleTicket {
  27.     int oldTicketsCount = self.ticketsCount;
  28.     sleep(.2);
  29.     oldTicketsCount--;
  30.     self.ticketsCount = oldTicketsCount;
  31.     NSLog(@"剩余%d张票", self.ticketsCount);
  32. }

打印结果：

  1. ～: 剩余14张票
  2. ～: 剩余13张票
  3. ～: 剩余14张票
  4. ～: 剩余12张票
  5. ～: 剩余12张票
  6. ～: 剩余12张票
  7. ～: 剩余11张票
  8. ～: 剩余10张票
  9. ～: 剩余9张票
  10. ～: 剩余8张票
  11. ～: 剩余7张票
  12. ～: 剩余6张票
  13. ～: 剩余5张票
  14. ～: 剩余4张票
  15. ～: 剩余3张票

期望余票应该是15 - 5 - 5 - 5 = 0张票。

3、解决方案

使用线程同步技术（同步，就是协同步调，按预定的先后次序进行），常见的线程同步技术是：加锁
比如上面提到的存钱取钱问题，在存钱之前先加锁，保证数据只有当前线程可以访问，在存钱结束时解锁。这时取钱线程访问数据，也进行加锁解锁操作，这样就能保证数据读写的安全性。
image.png