美文网首页
iOS中的网络和多线程编程(六)

iOS中的网络和多线程编程(六)

作者: anny_4243 | 来源:发表于2022-02-17 17:44 被阅读0次

    摘自《iOS程序员面试笔试宝典》

    什么是线程死锁

    在讲解线程死锁前,首先看下面代码有什么问题?

    int main(int argc, char * argv[]) {
        NSLog(@"1");
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"2");
        });
        NSLog(@"3");
        return 0;
    }
    

    在上述代码中,main函数中第二句代码在主线程上使用了dispatch_sync同步向主线程派发任务,而同步派发要等到任务完成后才能返回,阻塞当前线程。也就是说,执行到此处,主线程被阻塞,同时又要等主线程执行完成该任务,造成主线程自身的等待循环,也就是死锁。程序运行到此处会崩溃。将dispatch_sync改为dispatch_async异步派发任务即可避免死锁,或者将任务派发到其他队列上而不是主队列。

    dispatch_barrier_async的作用是什么

    通过dispatch_barrier_async添加的操作会暂时阻塞当前队列,即等待前面的并发操作都完成后执行该阻塞操作,待其完成后后面的并发操作才可继续。可以将其比喻为一根霸道的独木桥,是并发队列中的一个并发障碍点,或者说中间瓶颈,临时阻塞并独占。注意,dispatch_barrier_async只有在并发队列中才能起作用,在串行队列中队列本身就是独木桥,将失去其意义。

    dispatch_barrier_async阻塞队列

    可见使用dispatch_barrier_async可以实现类似dispatch_group_t组调度的效果,同时主要的作用是避免数据竞争,高效访问数据。

    /*创建并发队列*/
    dispatch_queue_t concurrentQueue = dispatch_queue_create("test.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
    /*添加两个并发操作A和B,即A和B会并发执行*/
    dispatch_async(concurrentQueue, ^{
        NSLog(@"OperationA");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"OperationB");
    });
        
    /*添加barrier障碍操作,会等待前面的并发操作结束,并暂时阻塞后面的并发操作直到其完成*/
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"OperationBarrier!");
    });
    /*继续添加并发操作C和D,要等待barrier障碍操作结束才能开始*/
    dispatch_async(concurrentQueue, ^{
        NSLog(@"OperationC");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"OperationD");
    });
    

    程序的输出结果为:

    如何理解线程安全

    在实际开发中,如果在程序中使用了多线程技术,那么有可能会遇到同一块资源被多个线程共享的情况,也就是多个线程可能会访问同一块资源,如多个线程访问同一对象、变量、文件等。因此,当多个线程访问同一块资源时,很容易会发生数据错误及数据不安全等问题。

    要避免这种因争夺资源而导致的数据安全问题,需要使用“线程锁”来解决,即在同一时间段内,只允许一个线程来使用资源。在iOS开发中主要使用如下几种线程锁技术。

    1.@synchronized关键字

    使用@synchronized能够很方便地隐式创建锁对象。示例代码如下:

    - (void)testSynchronized{
        Animal *someone = [Animal new];
        /*线程A*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            @synchronized (someone) {
                NSLog(@"线程 A=%@",[NSThread currentThread]);
                someone.name = @"123";
                [NSThread sleepForTimeInterval:5];
            }
        });
        
        /*线程B*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            @synchronized (someone) {
                NSLog(@"线程 B=%@",[NSThread currentThread]);
                someone.name = @"  ";
            }
        });
    }
    

    程序的输出结果为:

    可以发现线程B访问资源的时间比线程A要晚5s。关键字@synchronized将实例对象someone设定为锁的唯一标识,只有标识相同时,才满足互斥。如果线程B中锁的标识改为其他对象,那么线程B将不会被阻塞。

    2.NSLock

    NSLock对象是iOS中为了保证临界资源的原子性操作和临界区的原子性执行而封装的。需要注意的是,NSLock对象中的unlock操作必须与lock操作使用相同的线程,否则会出现未知错误。此外,同一线程在lock之后,未unlock之前,再次lock会导致永久性死锁。

    示例代码如下:

    - (void)testNSLock {
        Animal *someone = [Animal new];
        /*创建锁对象*/
        NSLock *alock = [[NSLock alloc]init];
        /*线程A*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            /*尝试上锁*/
            if ([alock tryLock]) {//[alock lock]
                NSLog(@"线程 A=%@",[NSThread currentThread]);
                someone.name = @"123";
                [NSThread sleepForTimeInterval:5];
                /*开锁*/
                [alock unlock];
            }
        });
        
        /*线程B*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            if ([alock tryLock]) {//[alock lock];
                NSLog(@"线程 B=%@",[NSThread currentThread]);
                someone.name = @"123";
                [alock unlock];
            }
        });
    }
    

    程序的输出结果为:

    结果显示线程B在等待线程A解锁之后,才会执行程序。如果线程B将lock和unlock方法去掉之后而不会被阻塞,那么这个和synchronized的一样,需要使用相同的锁对象才会互斥。

    除了NSLock之外,iOS还提供了NSRecursiveLock类和NSConditionLock类,前者通常在递归操作中使用,后者可以创建一个指定开锁条件的锁对象,只有满足条件,才能开锁。

    3.GCD

    GCD提供了一种信号的机制,使用它可以创建锁。信号量是一个整型值并且具有一个初始计数值,可支持两个操作:信号通知和等待。当一个信号量被信号通知,其计数会被增加。当一个线程在一个信号量上等待时,线程会被阻塞(如果有必要),直至计数器大于零,然后线程会减少这个计数。

    在GCD中有3个函数是semaphore的操作。

    semaphore操作的3个函数

    简单地介绍这3个函数,第一个函数有一个整型的参数,可以理解为信号的总量;dispatch_semaphore_signal是发送一个信号,自然会让信号总量加1;dispatch_semaphore_wait是等待信号,当信号总量少于0的时候就会一直等待,否则就可以正常地执行,并让信号总量-1。根据这样的原理,可以快速地创建一个并发控制来同步任务和有限资源访问控制。示例代码如下:

    - (void)testGCD{
        Animal *someone = [Animal new];
        dispatch_semaphore_t semaphone = dispatch_semaphore_create(1);
        /*线程 A*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            /*等待,如果信号大于0,那么继续并减少一个信号*/
            dispatch_semaphore_wait(semaphone, DISPATCH_TIME_FOREVER);
            NSLog(@"线程A=%@",[NSThread currentThread]);
            someone.name = @"123";
            [NSThread sleepForTimeInterval:5];
            /*信号加1*/
            dispatch_semaphore_signal(semaphone);
        });
        /*线程B*/
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            dispatch_semaphore_wait(semaphone, DISPATCH_TIME_FOREVER);
            NSLog(@"线程B=%@",[NSThread currentThread]);
            someone.name = @"456";
            dispatch_semaphore_signal(semaphone);
        });
    }
    

    程序的输出结果为:

    如何实现Cocoa中多线程的安全

    Cocoa中多线程编程的实现如下:

    1)Objective-C语言本身的NSThread。

    2)基于C语言封装的GCD。

    3)GCD的Objective-C封装NSOperation(NSOperationQueue)。

    4)兼容C语言的pthread。

    多线程的应用场景如下:

    1)在避免主线程阻塞,影响界面流畅性时,会利用多线程将耗时操作放到后台等其他线程执行,执行结束后再同步到主线程。

    2)大任务的分割并行要利用多线程实现,例如下载一张大图片,可以将图片分割成多个部分在多个线程上并行下载,下载完成后再拼接起来提高效率。

    3)并发任务的实现需要多线程,指的是某些任务并非先后排队执行,而必须是并发的、时间上会重合的,就需要将这些任务放置在不同的线程上执行(这里从多线程的使用层次来说,不考虑系统级的分时复用)。

    多线程安全的解决办法如下:

    1)对于UI界面的刷新访问操作要保证在主线程上,防止不能及时响应造成意想不到的结果。

    2)应用多线程要防止数据资源的抢夺,可通过使用@synchronized进行加锁在临界区安全地访问数据。

    3)尽量使用GCD开发多线程程序,防止线程安全的问题,因为GCD是经过优化的且很多函数默认就是线程安全的,可以大大减少开发过程中的线程安全问题。

    相关文章

      网友评论

          本文标题:iOS中的网络和多线程编程(六)

          本文链接:https://www.haomeiwen.com/subject/hpojlrtx.html