iOS多线程知识总结(队列概念/GCD/串行/并行/同步/异步)

先用比较通俗易懂的话解释一下同步、异步、串行、并行的概念:

同步、异步:

指的是能否开启新的线程。同步不能开启新的线程,异步可以(网上好多人这么总结,但是个人感觉是不准确的)。

(更加准确的解释是,同步(sync)和 异步(async)的主要区别在于会不会阻塞当前线程(即执行的时候是否需要等待)。如果是 同步(sync)操作,它会阻塞当前线程并等待当前的任务执行完毕,然后当前线程才会继续往下运行。如果是 异步(async)操作,当前线程会直接往下执行,它不会阻塞当前线程(要执行的任务可能跑到别的线程去执行)。)

串行、并行:

指的是任务的执行方式。串行是指多个任务时,各个任务按顺序执行,完成一个之后才能进行下一个。并行指的是多个任务可以同时执行。异步是多个任务并行的前提条件。



下面按照四种组合方式,来理解一下他们之间的区别:

 同步执行异步执行
串行队列当前线程,一个一个执行其他线程,一个一个执行
并行队列当前线程,一个一个执行开很多线程,一起执行

1.串行队列+同步:不会开启新的线程,任务按顺序完成。

2.串行队列+异步:开启新的线程,任务按顺序完成。

3.并发队列+同步:不会开启新的线程,任务按顺序完成。

4.并发队列+异步:开启新的线程,任务可以同步完成。

我们如果要让任务在新的线程中完成,应该使用异步线程。为了提高效率,我们还应该将任务放在并发队列中。因此在开发中使用最多的是并发队列+异步任务。看代码:

// 串行队列+同步任务

- (void)serialSyn{

    dispatch_queue_t queue =dispatch_queue_create("serial",DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"1---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"2---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"3---%@", [NSThreadcurrentThread]);

        }

    });

}

// 串行队列+异步任务

- (void)serialAsyn{

    dispatch_queue_t queue =dispatch_queue_create("serial",DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"1---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"2---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"3---%@", [NSThreadcurrentThread]);

        }

    });

}

// 并发队列+同步任务

- (void)concurrenSyn{

    dispatch_queue_t queue =dispatch_queue_create("concurrent",DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"1---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"2---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_sync(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"3---%@", [NSThreadcurrentThread]);

        }

    });

    

}

// 并发队列+异步任务

- (void)concurrentAsyn{

    dispatch_queue_t queue =dispatch_queue_create("concurrent",DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"1---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"2---%@", [NSThreadcurrentThread]);

        }

    });

    dispatch_async(queue, ^{

        for (int i =0; i <3; i ++) {

            NSLog(@"3---%@", [NSThreadcurrentThread]);

        }

    });

}


输出结果分别为:
// 串行队列+同步任务

2017-12-09 15:50:18.427989+0800 GCD[1044:27175] 1---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:20.912799+0800 GCD[1044:27277] XPC connection interrupted

2017-12-09 15:50:21.429204+0800 GCD[1044:27175] 1---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:24.430559+0800 GCD[1044:27175] 1---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:25.431937+0800 GCD[1044:27175] 2---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:26.433460+0800 GCD[1044:27175] 2---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:27.433913+0800 GCD[1044:27175] 2---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:28.435443+0800 GCD[1044:27175] 3---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:29.435987+0800 GCD[1044:27175] 3---<NSThread: 0x600000073600>{number = 1, name = main}

2017-12-09 15:50:30.437512+0800 GCD[1044:27175] 3---<NSThread: 0x600000073600>{number = 1, name = main}


// 串行队列+异步任务

2017-12-09 16:08:03.242688+0800 GCD[1252:41773] 1---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:06.246989+0800 GCD[1252:41773] 1---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:09.249206+0800 GCD[1252:41773] 1---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:10.250193+0800 GCD[1252:41773] 2---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:11.250878+0800 GCD[1252:41773] 2---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:12.255908+0800 GCD[1252:41773] 2---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:13.258215+0800 GCD[1252:41773] 3---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:14.258708+0800 GCD[1252:41773] 3---<NSThread: 0x600000276ec0>{number = 3, name = (null)}

2017-12-09 16:08:15.259192+0800 GCD[1252:41773] 3---<NSThread: 0x600000276ec0>{number = 3, name = (null)}


// 串行队列+异步任务

2017-12-09 16:09:23.548551+0800 GCD[1283:42913] 1---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:25.547003+0800 GCD[1283:43153] XPC connection interrupted

2017-12-09 16:09:26.549830+0800 GCD[1283:42913] 1---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:29.550406+0800 GCD[1283:42913] 1---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:30.551134+0800 GCD[1283:42913] 2---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:31.552655+0800 GCD[1283:42913] 2---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:32.553861+0800 GCD[1283:42913] 2---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:33.555326+0800 GCD[1283:42913] 3---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:34.555842+0800 GCD[1283:42913] 3---<NSThread: 0x604000260540>{number = 1, name = main}

2017-12-09 16:09:35.556267+0800 GCD[1283:42913] 3---<NSThread: 0x604000260540>{number = 1, name = main}


// 并发队列+异步任务

2017-12-09 16:10:26.676320+0800 GCD[1309:44938] 3---<NSThread: 0x604000466c40>{number = 3, name = (null)}

2017-12-09 16:10:26.676320+0800 GCD[1309:44937] 2---<NSThread: 0x60000066e380>{number = 4, name = (null)}

2017-12-09 16:10:27.678310+0800 GCD[1309:44938] 3---<NSThread: 0x604000466c40>{number = 3, name = (null)}

2017-12-09 16:10:27.678316+0800 GCD[1309:44937] 2---<NSThread: 0x60000066e380>{number = 4, name = (null)}

2017-12-09 16:10:28.674756+0800 GCD[1309:44935] 1---<NSThread: 0x60000066fa80>{number = 5, name = (null)}

2017-12-09 16:10:28.679805+0800 GCD[1309:44938] 3---<NSThread: 0x604000466c40>{number = 3, name = (null)}

2017-12-09 16:10:28.679798+0800 GCD[1309:44937] 2---<NSThread: 0x60000066e380>{number = 4, name = (null)}

2017-12-09 16:10:31.675355+0800 GCD[1309:44935] 1---<NSThread: 0x60000066fa80>{number = 5, name = (null)}

2017-12-09 16:10:34.678046+0800 GCD[1309:44935] 1---<NSThread: 0x60000066fa80>{number = 5, name = (null)}



从上边打印的执行任务的顺序,可以看出四种组合方式的区别了。


下面用专业的术语来解释一下进程、线程、队列、GCD、串行、并行、同步、异步等概念:

 

进程:正在进行中的程序被称为进程,负责程序运行的内存分配;每一个进程都有自己独立的虚拟内存空间;

线程:线程是进程中一个独立的执行路径(控制单元);一个进程中至少包含一条线程,即主线程。

队列dispatch_queue_t,一种先进先出的数据结构,线程的创建和回收不需要程序员操作,由队列负责。

  串行队列:队列中的任务只会顺序执行(类似跑步)

      dispatch_queue_t q = dispatch_queue_create(“....”, dispatch_queue_serial);

  并行队列:队列中的任务通常会并发执行(类似赛跑)

        dispatch_queue_t q = dispatch_queue_create("......", dispatch_queue_concurrent);

  全局队列:是系统开发的,直接拿过来(get)用就可以;与并行队列类似,但调试时,无法确认操作所在队列

        dispatch_queue_t q = dispatch_get_global_queue(dispatch_queue_priority_default, 0);

  主队列:每一个应用程序对应唯一一个主队列,直接get即可;在多线程开发中,使用主队列更新UI

      dispatch_queue_t q = dispatch_get_main_queue();

操作

   dispatch_async 异步操作,会并发执行,无法确定任务的执行顺序;

   dispatch_sync 同步操作,会依次顺序执行,能够决定任务的执行顺序;

 

串行队列同步:操作不会新建线程、操作顺序执行;

串行队列异步:操作需要一个子线程,会新建线程、线程的创建和回收不需要程序员参与,操作顺序执行,是最安全的选择;

 

并行队列同步:操作不会新建线程、操作顺序执行;

并行队列异步:操作会新建多个线程、操作无序执行;


全局队列同步:操作不会新建线程、操作顺序执行;

全局队列异步:操作会新建多个线程、操作无序执行;

 

主队列异步:操作都应该在主线程上顺序执行的,不存在异步的;

主队列同步:如果把主线程中的操作看成一个大的block,那么除非主线程被用户杀掉,否则永远不会结束;主队列中添加的同步操作永远不会被执行,会死锁

 

不同队列嵌套dispathch_sync(同步)任务的结果

 // 1.全局队列,都在主线程上执行,不会死锁 dispatch_queue_priority_default

 dispatch_queue_t q = dispatch_get_global_queue(dispatch_queue_priority_default, 0);

 // 2.并行队列,都在主线程上执行,不会死锁 dispatch_queue_concurrent

 dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", dispatch_queue_concurrent);

 // 3.串行队列,会死锁,但是会执行嵌套同步操作之前的代码 dispatch_queue_serial

 dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", dispatch_queue_serial);

 // 4.主队列,直接死锁 dispatch_get_main_queue();

 dispatch_queue_t q = dispatch_get_main_queue();

 

dispatch_sync同步应用开发场景

阻塞并行队列的执行,要求某一操作执行后再进行后续操作,如用户登录

确保块代码之外的局部变量确实被修改

dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", dispatch_queue_concurrent);

__block bool login = no;

dispatch_sync(q, ^{

nslog(@"模拟耗时操作 %@", [nsthread currentthread]);

[nsthread sleepfortimeinterval:2.0f];

nslog(@"模拟耗时完成 %@", [nsthread currentthread]);

login = yes; 

 });

dispatch_async(q, ^{

nslog(@"登录完成的处理 %@", [nsthread currentthread]);

});

ios三种多线程技术

   1.nsthread

     (1)使用nsthread对象建立一个线程非常方便

     (2)但是!要使用nsthread管理多个线程非常困难,不推荐使用

     (3)技巧!使用[nsthread currentthread]跟踪任务所在线程,适用于这三种技术

   2.nsoperation/nsoperationqueue

     (1)是使用gcd实现的一套objective-c的api

     (2)是面向对象的线程技术

     (3)提供了一些在gcd中不容易实现的特性,如:限制最大并发数量、操作之间的依赖关系

   3.gcd —— grand central dispatch

     (1)是基于c语言的底层api

     (2)用block定义任务,使用起来非常灵活便捷

     (3)提供了更多的控制能力以及操作队列中所不能使用的底层函数

 

1---- 队列和线程的区别:

队列:是管理任务的,能管理任务什么时候执行。

队列分为串行队列和并行队列:

串行队列:队列中的任务按顺序执行(不会同时执行)

并行队列:队列中的任务会并发执行,可能会有一个疑问,队列不是先进先出吗,如果后面的任务执行完了,怎么出去的了。这里需要强调下,任务执行完毕了,不一定出队列。只有前面的任务执行完了,才会出队列。

2----- 主线程队列和gcd创建的队列也是有区别的。

主线程队列和gcd创建的队列是不同的。在gcd中创建的队列优先级没有主队列高,所以在gcd中的串行队列开启同步任务里面没有嵌套任务是不会阻塞主线程,只有一种可能导致死锁,就是串行队列里,嵌套开启任务,有可能会导致死锁。

主线程队列中不能开启同步,会阻塞主线程。只能开启异步任务,开启异步任务也不会开启新的线程,只是降低异步任务的优先级,让cpu空闲的时候才去调用。而同步任务,会抢占主线程的资源,会造成死锁。

3----- 线程:里面有非常多的任务(同步,异步)

同步与异步的区别:

同步任务优先级高,在线程中有执行顺序,会等待,不会开启新的线程。 

异步任务优先级低,在线程中执行没有顺序,要执行时不需要等待,在主队列中不会开启新的线程,其他队列可能会开启新的线程。

4----主线程队列注意: 

 在主队列开启异步任务,不会开启新的线程而是依然在主线程中执行代码块中的代码。为什么不会阻塞线程?

 > 主队列开启异步任务,虽然不会开启新的线程,但是他会把异步任务降低优先级,等闲着的时候,就会在主线程上执行异步任务。

 在主队列开启同步任务,为什么会阻塞线程?

 > 在主队列开启同步任务,因为主队列是串行队列,里面的线程是有顺序的,先执行完一个线程才执行下一个线程,而主队列始终就只有一个主线程,主线程是不会执行完毕的,因为他是无限循环的,除非关闭应用开发程序。因此在主线程开启一个同步任务,同步任务会想抢占执行的资源,而主线程任务一直在执行某些操作,不肯放手。两个的优先级都很高,最终导致死锁,阻塞线程了。


参考:https://www.cnblogs.com/hrios/p/thr.html

         https://blog.csdn.net/u010105969/article/details/69914369

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页