iOS 互斥锁简单使用

最新推荐文章于 2024-08-16 23:36:26 发布

weixin_33834137

最新推荐文章于 2024-08-16 23:36:26 发布

阅读量1k

点赞数

文章标签： python 移动开发

原文链接：https://my.oschina.net/mexiaobai1315/blog/1549115

版权

2019独角兽企业重金招聘Python工程师标准>>>

@synchronized

@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其它线程访问，起到线程的保护作用.

-(void)viewDidLoad
{
    self.totalCount = 100;
    
    self.lock = [[NSLock alloc] init];
    
    self.threadA = [[NSThread alloc] initWithTarget:self selector:@selector(sale) object:nil];
    self.threadA.name = @"售票员A";
    
    self.threadB = [[NSThread alloc] initWithTarget:self selector:@selector(sale) object:nil];
    self.threadB.name = @"售票员B";
    
    self.threadC = [[NSThread alloc] initWithTarget:self selector:@selector(sale) object:nil];
    self.threadC.name = @"售票员C";
}

-(void)sale
{
    while (1) {
        
        //使用synchronized保证同一时间只能有一个出票的行为；
        @synchronized(self){

            NSInteger count = self.totalCount;
            
            for(NSInteger i = 0; i < 100000; i++){
                
            }
            
            if(count > 0){
                self.totalCount = count - 1;
                NSLog(@"%@卖了一张票, 还剩%zd张票",[NSThread currentThread].name, self.totalCount);
            }else{
                NSLog(@"票卖完了");
                break;
            }
        }
      };
    }
}

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self.threadA start];
    [self.threadB start];
    [self.threadC start];
}

NSLock

lock:加锁
unlock:解锁
tryLock:尝试加锁，返回值是布尔类型；返回YES，加锁成功；返回NO，加锁失败，立即退出，不会阻塞线程；

-(void)sale
{
    while (1) {
        
        //尝试加锁，返回YES，执行代码，并解锁；返回NO，不执行操作；
        //也可以直接执行 [self.lock lock]加锁
        if([self.lock tryLock]){

            NSInteger count = self.totalCount;
            
            for(NSInteger i = 0; i < 100000; i++){
                
            }
            
            if(count > 0){
                self.totalCount = count - 1;
                NSLog(@"%@卖了一张票, 还剩%zd张票",[NSThread currentThread].name, self.totalCount);
            }else{
                NSLog(@"票卖完了");
                break;
            }
            
            [self.lock unlock];
        }
    }
}

NSConditionLock

NSConditionLock和NSLock类似，参数多了一个condition；加锁时 lockWhenCondition、tryLockWhenCondition,只有 condition 参数与初始化时候的 condition 相等，lock 才能正确进行加锁操作; 解锁 unlockWithCondition，并不是condition符合条件才解锁，而是解锁时修改condition的值

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       
        [self.conditionLock lockWhenCondition:0];
        NSLog(@"线程1");
        sleep(1);
        [self.conditionLock unlock];
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
//        [self.conditionLock lockWhenCondition:1];
        [self.conditionLock tryLockWhenCondition:1];
        NSLog(@"线程2");
        sleep(1);
        [self.conditionLock unlockWithCondition:2];
        NSLog(@"线程2解锁成功");
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
//        [self.conditionLock lockWhenCondition:2];
        [self.conditionLock tryLockWhenCondition:2];
        NSLog(@"线程3");
        sleep(1);
        [self.conditionLock unlockWithCondition:0];
        NSLog(@"线程3解锁成功");
    });
}

执行结果：

2017-10-11 11:16:58.142126+0800 test[4652:1892785] 线程2
2017-10-11 11:16:59.147742+0800 test[4652:1892785] 线程2解锁成功
2017-10-11 11:16:59.147951+0800 test[4652:1892784] 线程3
2017-10-11 11:17:00.151930+0800 test[4652:1892784] 线程3解锁成功
2017-10-11 11:17:00.152230+0800 test[4652:1892783] 线程1

NSRecursiveLock

NSRecursiveLock是递归锁，他和 NSLock 的区别在于，NSRecursiveLock 可以在一个线程中重复加锁（反正单线程内任务是按顺序执行的，不会出现资源竞争问题），NSRecursiveLock 会记录上锁和解锁的次数，当二者平衡的时候，才会释放锁，其它线程才可以上锁成功。

NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

    static void (^RecursiveBlock)(int);
    RecursiveBlock = ^(int value) {
        [lock lock];
        if (value > 0) {
            NSLog(@"value:%d", value);
            RecursiveBlock(value - 1);
        }
        [lock unlock];
    };
    RecursiveBlock(2);
});

2017-10-11 11:31:08.792344+0800 test[4668:1898431] value:2 2017-10-11 11:31:08.792516+0800 test[4668:1898431] value:1

如上面的示例，如果用 NSLock 的话，lock 先锁上了，但未执行解锁的时候，就会进入递归的下一层，而再次请求上锁，阻塞了该线程，线程被阻塞了，自然后面的解锁代码不会执行，而形成了死锁。而 NSRecursiveLock 递归锁就是为了解决这个问题。

NSCondition

NSCondition 的对象实际上作为一个锁和一个线程检查器，锁上之后其它线程也能上锁，而之后可以根据条件决定是否继续运行线程，即线程是否要进入 waiting 状态，经测试，NSCondition 并不会像上文的那些锁一样，先轮询，而是直接进入 waiting 状态，当其它线程中的该锁执行 signal 或者 broadcast 方法时，线程被唤醒，继续运行之后的方法。 signal 只是一个信号量，只能唤醒一个等待的线程，想唤醒多个就得多次调用，而 broadcast 可以唤醒所有在等待的线程。如果没有等待的线程，这两个方法都没有作用。

dispatch_async(dispatch_get_global_queue(0, 0), ^{
       
        [self.condition lock];
        
        if(self.array.count == 0){
            [self.condition wait];
        }
        
        [self.array removeAllObjects];
        NSLog(@"remove all objects");
        [self.condition unlock];
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       
        sleep(1);
        [self.condition lock];
        [self.array addObject:@1];
        NSLog(@"add object");
        [self.condition signal];
        [self.condition unlock];
    });

dispatch_semaphore

dispatchsemaphorecreate(long value);

dispatchsemaphorewait(dispatchsemaphoret dsema, dispatchtimet timeout);

dispatchsemaphoresignal(dispatchsemaphoret dsema); dispatch_semaphore 是 GCD 用来同步的一种方式，与他相关的只有三个函数，一个是创建信号量，一个是等待信号，一个是发送信号。

dispatch_semaphore_t signal = dispatch_semaphore_create(1);
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    dispatch_semaphore_wait(signal, overTime);
    sleep(2);
    NSLog(@"线程1");
    dispatch_semaphore_signal(signal);
});


dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(1);
    dispatch_semaphore_wait(signal, overTime);
    NSLog(@"线程2");
    dispatch_semaphore_signal(signal);
});

dispatchsemaphore 和 NSCondition 类似，都是一种基于信号的同步方式，但 NSCondition 信号只能发送，不能保存（如果没有线程在等待，则发送的信号会失效）。而 dispatchsemaphore 能保存发送的信号。dispatchsemaphore 的核心是 dispatchsemaphore_t 类型的信号量。

dispatchsemaphorecreate(1) 方法可以创建一个 dispatchsemaphoret 类型的信号量，设定信号量的初始值为 1。注意，这里的传入的参数必须大于或等于 0，否则 dispatchsemaphorecreate 会返回 NULL。

dispatchsemaphorewait(signal, overTime); 方法会判断 signal 的信号值是否大于 0。大于 0 不会阻塞线程，消耗掉一个信号，执行后续任务。如果信号值为 0，该线程会和 NSCondition 一样直接进入 waiting 状态，等待其他线程发送信号唤醒线程去执行后续任务，或者当 overTime 时限到了，也会执行后续任务。

dispatchsemaphoresignal(signal); 发送信号，如果没有等待的线程接受信号，则使 signal 信号值加一（做到对信号的保存）。

从上面的实例代码可以看到，一个 dispatchsemaphorewait(signal, overTime); 方法会去对应一个 dispatchsemaphoresignal(signal); 看起来像 NSLock 的 lock 和 unlock，其实可以这样理解，区别只在于有信号量这个参数，lock unlock 只能同一时间，一个线程访问被保护的临界区，而如果 dispatch_semaphore 的信号量初始值为 x ，则可以有 x 个线程同时访问被保护的临界区。

转载于:https://my.oschina.net/mexiaobai1315/blog/1549115