iOS线程同步,线程和锁

线程同步：即当有一个线程在对内存进行操做时，其余线程都不能够对这个内存地址进行操做，直到该线程完成操做，其余线程才能对该内存地址进行操做。面试

因此这里同步应该不是一块儿、共同完成的意思，可理解为协调就是按预约的前后次序进行工做，比如: '不要和我抢了，你先等会我作完了你在作'。算法

线程同步目的为了多个线程都能很好的工做，合理的访问系统资源不争不抢、和谐共处。iOS开发中经常使用的保持线程同步有如下几种：markdown

经过线程加锁
串行队列
GCD

线程加锁

经常使用的几种形式的锁网络

一、 @synchronized

- (void)myMethod:(id)anObj
{
    @synchronized(anObj)
    {
        //执行的代码操做
    }
}
复制代码

经过***synchronized指令***自动的添加一个互斥锁，底层经过pthread_mutex实现。经过对一段代码的使用进行加锁。其余试图执行该段代码的线程都会被阻塞，直到加锁线程退出执行该段被保护的代码段。多线程

当在@synchronized()代码块中抛出异常的时候，Objective-C运行时会捕获到该异常，并释放信号量，并把该异常从新抛出给下一个异常处理者。架构

一个线程是能够以递归的方式屡次调用***myMethod***。async

关于参数***anObj***;oop

做为一个惟一标识符来标记当前线程加锁操做必须是个对象类型，因此对于同一个操做不一样的线程应该用同一个对象，不然没法起到标记加锁的做用。不能为空nil。学习

常见的基本都是***self***url

@synchronized(self)
{
    //执行的代码操做
}
复制代码

self做为标记符十分常见，可是很明显会有一个问题:

//方法1
- (void)myMethod1:(id)anObj
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT , 0), ^{
        @synchronized(anObj)
        {
            //执行的代码操做
        }
    });
}
//方法2
- (void)myMethod2:(id)anObj
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT , 0), ^{
        @synchronized(anObj)
        {
            //执行的代码操做
        }
    });
}

myMethod1(self);
myMethod2(self)</pre>
复制代码

若是myMethod一、myMethod2没用任何关系，若是此时执行myMethod1，那么myMethod2就只能等待其执行完成。因此这种状况更细的粒度来加锁，使用各自的对象互不影响更为合理。

* 二、NSLock ``` NSLock * lock = [[NSLock alloc]init]; [lock lock]; //执行的代码操做 [lock unlock]; ``` 底层经过pthread_mutex实现；方法lock、unlock必须成对出现，必须在同一个线程中操做不然无效。不支持递归，若是屡次调用会形成死锁。

若是多个线程共用一个**lock ，一个线程加锁后其余请求加锁的线程会造成一个等待队列、按照先进先出的规则等待锁释放后再加锁(待验证)。

* 三、NSRecursiveLock 递归锁相似NSLock，但它能够在同一个线程中反复加锁且不会形成死锁。

* 四、 NSCondition `基于信号量方式实现的锁对象，提供单独的信号量管理接口。底层经过pthread_cond_t实现。`

NSCondition对象包含锁和条件检测功能，相似于生产者和消费者：消费者消费资源若是没有就继续等待，生产者提供资源而后发出信号激活消费者。锁的做用就是用来保护这一操做防止被其余线程干扰。

DEMO:

__weak typeof(self) weakSelf = self;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [weakSelf _user];
    });
复制代码

[weakSelf _produce];
    });
复制代码

-(void)_user{
    [condition lock];

    while (isWait) {
        //等待其余线程发出信号,[condition signal];
        //阻塞当前线程
        NSLog(@"等待条件知足");
        [condition wait];
    }
    {
        //执行操做
        NSLog(@"执行操做");
    }

    //完成
    [condition unlock];

    NSLog(@"完成");
}

-(void)_produce{
    [condition lock];
     isWait = false;
     [condition signal];
     [condition unlock];
}
复制代码

输出结果:

[13781:212898] 等待条件知足
[13781:212898] 执行操做
[13781:212898] 完成</pre>
复制代码

* ####五、 NSConditionLock 可使用特定值来加锁和解锁，和**`NSCondition`**表现差很少。

(instancetype)initWithCondition:(NSInteger)condition 参数**condition做为标识符更容易理解，lockWhenCondition获取指定标记的锁没有的话就阻塞当前线程，unlockWithCondition:**释放指定标记的锁，等他的线程获取锁而后继续执行操做。

使用上比**NSCondition**更方便些，代码更简洁。

用**NSConditionLock**改写以上代码:

-(void)_testConditionLock{
    __weak typeof(self) weakSelf = self;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [weakSelf _user1];
    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [weakSelf _produce1];
    });
}
-(void)_user1{
    NSLog(@"等待条件知足");
    [conditionLock lockWhenCondition:11];

    NSLog(@"条件知足了");

    {
        //执行操做
        NSLog(@"执行操做");
    }

    //完成
    [conditionLock unlockWithCondition:0];

    NSLog(@"完成");
}

[self _testConditionLock];</pre>
复制代码

输出结果:

[7812:120141] 等待条件知足
[7812:120137] 生成条件中...
[7812:120141] 条件知足了
[7812:120141] 执行操做
[7812:120141] 完成</pre>
复制代码

* #### 六、其余不经常使用的锁 pthread_mutex pthread_mutex(recursive) POSIX标准的unix多线程,C 语言下多线程实现。

***OSSpinLock:***自旋锁，一直轮询等待时会消耗大量 CPU 资源。

串行队列

经过建立一个串行队列，把咱们的操做添加到队列。

dispatch_queue_t queue = dispatch_queue_create("com.queue.test",DISPATCH_QUEUE_SERIAL);

dispatch_async(queue, ^{
    NSLog(@"task 1");
});
dispatch_async(queue, ^{
    NSLog(@"task 2");
});

dispatch_async(queue, ^{
    NSLog(@"task 3");
});</pre>
复制代码

感受建立队列、添加操做到队列太麻烦，不够简洁并且队列的调度确定占用很多资源.

### GCD

经过dispatch_semaphore信号量实现线程同步

dispatch_semaphore_create(long value);

dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);//-1

dispatch_semaphore_signal(dispatch_semaphore_t dsema);//+1</pre>
复制代码

***dispatch_semaphore_wait在信号量为0时会阻塞当前线程，等待dispatch_semaphore_signal***释放信号而后继续执行。

用信号量改写以上代码:

-(void)_testSemaphore{
    __weak typeof(self) weakSelf = self;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [weakSelf _user2];
    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [weakSelf _produce2];
    });
}
-(void)_user2{
    NSLog(@"等待条件知足");
    dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);

    NSLog(@"条件知足了");

    {
        //执行操做
        NSLog(@"执行操做");
    }

    //完成
    NSLog(@"完成");
}

-(void)_produce2{
    NSLog(@"生成条件中...");
     dispatch_semaphore_signal(semaphore);
}
复制代码

semaphore = dispatch_semaphore_create(0);
    NSLog(@"初始化信号0");

    [self _testSemaphore];</pre>
复制代码

输出:

[9581:159120] 初始化信号0

[9581:159194] 生成条件中... [9581:159195] 等待条件知足 [9581:159195] 条件知足了 [9581:159195] 执行操做 [9581:159195] 完成

总结

经常使用的线程间同步方式就这些了，实际中用的信号量和NSLock比较多。至于其余的不是由于很差而是由于习惯了，不到很必须的时候我感受都差很少。真正由于其自己所占用的开销通常可忽略不计。

实践前先后后持续了一周的时间，总算进一步加深了认知。写完了才感受这些知识才是本身的，而后在慢慢吸取、消化，才能伴随咱们一步步的走向强大。

将来的路很长，不知道会走多远，只想走好脚下的每一步！

做为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是个人iOS交流圈: 无论你是小白仍是大牛欢迎入驻！！分享内容包括跳槽面试宝典、逆向安防、算法、架构设计、多线程，网络进阶，还有底层、音视频、Flutter等等......

本身根据梳理网络来的的开发经验总结的学习方法，无偿分享给你们。更多资源，须要的话均可以自行来获取下载。 +裙：196800191、或者是+ WX（XiAZHiGardenia）免费获取！获取面试资料简历模板一块儿交流技术资源集合

谢谢你长的这么好看，还关注我！！！点个赞呗！！

若是有什么不对的请各位大佬留言提示，而后有什么别的须要改进的提示请联系我我会及时补充~

over.over.

iOS线程同步,线程和锁

线程加锁

串行队列

总结

谢谢你长的这么好看，还关注我！！！点个赞呗！！

若是有什么不对的请各位大佬留言提示，而后有什么别的须要改进的提示请联系我我会及时补充~

部分文章来自转载网络，若有侵权请联系做者删除