多线程-互斥锁

上篇文章中讲到了多线程访问共享资源时,会产生数据错乱,解决这个问题的方法就是,通过互斥锁保护公共资源

互斥锁:有效防止因多线程抢夺资源造成的数据安全问题(线程同步技术) :

@synchronized(锁对象){ 锁定代码 }

当一条线程访问通过互斥锁访问公共资源时,进行加锁保护,当其他线程执行到这里,需要访问公共资源时,会在锁外等候,当前一线程执行完互斥锁内的任务,会通知锁外等候的线程,这样后面的线程再开启锁保护,执行锁内的任务
实现同一时间 , 只有一条线程可以对公共资源进行读写操作

示例代码:

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController{
    NSInteger _totalCounts;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    _totalCounts = 10;
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {

    NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(demo) object:nil];
    NSThread *thread2 = [[NSThread alloc] initWithTarget:self selector:@selector(demo) object:nil];
    
    [thread1 start];
    [thread2 start];
}

- (void)demo{
    
    /*
        互斥锁(线程同步)  :  
                @synchronized(锁对象){ 
                    锁定代码
                }
     
        作为锁对象的条件:
            1: 继承自NSObject
            2: 必须是全局的
     */
    
    @synchronized (self) {
        
        for (int i = 0; i < 10 ;i ++) {
            
            if (_totalCounts > 0) {
                
                _totalCounts--;
                NSLog(@"%zd",_totalCounts);
                
            }else{
                
                NSLog(@"停止");
                break;
            }
        } 
    }
}
@end

作为锁对象的两个条件:
1: 继承自NSObject
2: 必须是全局的

如果不满足全局,就不能保证锁的唯一性,相当于入口不唯一:
当一条线程访问公共资源前进行了加锁,另外一条线程访问公共资源前也加了锁,两个线程从不同的入口进入,获取到了公共资源,这样也就失去了意义

而之所以使用self,是因为self是最容易获取到的2个条件都满足的全局锁对象

• __互斥锁的原理 : __
  1: 默认继承自NSObject的对象内部都有一把互斥锁,默认开启状态
  2: 当执行到@synchronized关键字时,会先检查对象的锁的状态是开启还是关闭,通过锁对象内部的锁,锁住大括号内的代码,再去执行大括号内的代码,这样其他线程就被挡在锁外等候,当进入互斥锁内部的线程执行完锁内代码后,会重新打开互斥锁,这样在锁外等候的线程就可以进来了,重复加锁-->执行内部代码-->解锁的操作

加锁后的程序执行效率比不加锁的时候要低,因为线程需要等待锁
但是锁保证了多个线程同时操作公共资源的安全性