IOS多线程知识总结/队列概念/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 同步操做，会依次顺序执行，可以决定任务的执行顺序；

 

 串行队列同步：操做不会新建线程、操做顺序执行

 串行队列异步：操做须要一个子线程，会新建线程、线程的建立和回收不须要程序员参与，操做顺序执行，“最安全的选择”

 

 

 并行队列同步：操做不会新建线程、操做顺序执行

 

 并行队列异步：操做会新建多个线程（有多少任务，就开N个线程执行）、操做无序执行；队列前若是有其余任务，会等待前面的任务完成以后再执行；场景：既不影响主线程，又不须要顺序执行的操做！

 

 

 

 全局队列异步：操做会新建多个线程、操做无序执行，队列前若是有其余任务，会等待前面的任务完成以后再执行

 

 全局队列同步：操做不会新建线程、操做顺序执行

 

 

 

 主队列异步：操做都应该在主线程上顺序执行的，不存在异步的概念

 

 主队列同步：若是把主线程中的操做当作一个大的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(q, ^{

 

 NSLog(@"同步任务 %@", [NSThread currentThread]);

 

 dispatch_sync(q, ^{

 

 NSLog(@"同步任务 %@", [NSThread currentThread]);

 

 });

 

 });

 

 

 

 dispatch_sync同步应用场景

 

 阻塞并行队列的执行，要求某一操做执行后再进行后续操做，如用户登陆

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

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

 

 __block BOOL logon = NO;

 

 dispatch_sync(q, ^{

 

 NSLog(@"模拟耗时操做 %@", [NSThread currentThread]);

 

 [NSThread sleepForTimeInterval:2.0f];

 

 NSLog(@"模拟耗时完成 %@", [NSThread currentThread]);

 

 logon = 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----- 线程：里面有很是多的任务（同步，异步）

 

 同步与异步的区别：

 

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

 

 异步任务优先级低，在线程中执行没有顺序，看cpu闲不闲。在主队列中不会开启新的线程，其余队列会开启新的线程。

 

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

 

 下面代码执行顺序

 

 1111

 

 2222

 

 主队列异步 <NSThread: 0x8e12690>{name = (null), num = 1}

 

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

 

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

 

 在主队列开启同步任务，为何会阻塞线程？

 

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

 

 

 

 /*

 

 1.主队列

 

 */

 

- (void)main_queue_deadlock

 

{

    

    dispatch_queue_t q = dispatch_get_main_queue();

    

    NSLog(@"1111");

    

    dispatch_async(q, ^{

        

        NSLog(@"主队列异步任务 %@", [NSThread currentThread]);

        

    });

    

    NSLog(@"2222");

    

    // 下面会形成线程死锁

    

    //    dispatch_sync(q, ^{

    

    //        NSLog(@"主队列同步 %@", [NSThread currentThread]);

    

    //    });

    

}

 

 

 

/**

 

 *  2.并行队列里开启同步任务是有执行顺序的，只有异步才没有顺序

 

 */

 

- (void)concurrent_queue

 

{

    

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

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@1111111", [NSThread currentThread]);

        

        

        

        dispatch_sync(q, ^{

            

            NSLog(@"同步任务 %@2222222", [NSThread currentThread]);

            

        });

        

        dispatch_sync(q, ^{

            

            NSLog(@"同步任务 %@333333", [NSThread currentThread]);

            

        });

        

    });

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@444444", [NSThread currentThread]);

        

    });

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@555555", [NSThread currentThread]);

        

    });

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@666666", [NSThread currentThread]);

        

    });

    

}

 

 

 

/**

 

 *  3.串行队列开启异步任务，是有顺序的

 

 */

 

- (void)serial_queue

 

{

    

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

    

    

    

    dispatch_async(q, ^{

        

        NSLog(@"异步任务 %@1111111", [NSThread currentThread]);

        

    });

    

    dispatch_async(q, ^{

        

        NSLog(@"异步任务 %@22222", [NSThread currentThread]);

        

    });

    

    dispatch_async(q, ^{

        

        NSLog(@"异步任务 %@3333", [NSThread currentThread]);

        

    });

    

    dispatch_async(q, ^{

        

        NSLog(@"异步任务 %@44444", [NSThread currentThread]);

        

    });

    

}

 

 

 

/**

 

 *  4.1.串行队列开启异步任务后嵌套同步任务形成死锁

 

 */

 

- (void)serial_queue_deadlock2

 

{

    

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

    

    dispatch_async(q, ^{

        

        NSLog(@"异步任务 %@", [NSThread currentThread]);

        

        // 下面开启同步形成死锁：由于串行队列中线程是有执行顺序的，须要等上面开启的异步任务执行完毕，才会执行下面开启的同步任务。而上面的异步任务还没执行完，要到下面的大括号才算执行完毕，而下面的同步任务已经在抢占资源了，就会发生死锁。

        

        dispatch_sync(q, ^{

            

            NSLog(@"同步任务 %@", [NSThread currentThread]);

            

        });

        

    });

    

}

 

 

 

/**

 

 *  4.2.串行队列开启同步任务后嵌套同步任务形成死锁

 

 */

 

- (void)serial_queue_deadlock1

 

{

    

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

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@", [NSThread currentThread]);

        

        // 下面开启同步形成死锁：由于串行队列中线程是有执行顺序的，须要等上面开启的同步任务执行完毕，才会执行下面开启的同步任务。而上面的同步任务还没执行完，要到下面的大括号才算执行完毕，而下面的同步任务已经在抢占资源了，就会发生死锁。

        

        dispatch_sync(q, ^{

            

            NSLog(@"同步任务 %@", [NSThread currentThread]);

            

        });

        

        

        

    });

    

    NSLog(@"同步任务 %@", [NSThread currentThread]);

    

}

 

 

 

/**

 

 *  4.3.串行队列开启同步任务后嵌套异步任务不形成死锁

 

 */

 

- (void)serial_queue1

 

{

    

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

    

    dispatch_sync(q, ^{

        

        NSLog(@"同步任务 %@", [NSThread currentThread]);

        

        

        

        // 开启异步，就会开启一个新的线程,不会阻塞线程

        

        dispatch_async(q, ^{

            

            NSLog(@"异步任务 %@", [NSThread currentThread]);

            

        });

        

        

        

    });

    

    NSLog(@"同步任务 %@", [NSThread currentThread]);

    

}