tigerfly66
tigerfly66

IOS多线程

基本内容：

线程同步执行：不开启新线程，同步添加任务到指定队列，顺序执行任务。

线程异步执行：可开启新线程，异步添加任务到指定队列，异步执行。

串行队列：单个执行先进先出原则顺序执行（主队列是特殊的串行队列）

并行队列：多个任务同时执行 （系统提供的Gooble并行队列）

同步，不论你在何种队列，阻塞当前代码执行。。。

异步，不论再何种队列，都不阻塞当前代码执行

// 串行队列的创建方法

dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

// 主队列的获取方法

dispatch_queue_t queue = dispatch_get_main_queue();

// 并发队列的创建方法

dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

// 全局并发队列的获取方法

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 同步执行任务创建方法

dispatch_sync(queue, ^{

    // 这里放同步执行任务代码

});

// 异步执行任务创建方法

dispatch_async(queue, ^{

    // 这里放异步执行任务代码

});

所以组合的情况可以总结为：



我们来分别举例：

/**

* 异步执行 + 串行队列

* 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。

*/

- (void)asyncSerial {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"asyncSerial---begin");

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    dispatch_async(queue, ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    dispatch_async(queue, ^{

        // 追加任务3

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    NSLog(@"asyncSerial---end");

}

输出结果为：

2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread---{number = 1, name = main}

2018-02-23 20:41:17.030212+0800 YSC-GCD-demo[20008:5024757] asyncSerial---begin

2018-02-23 20:41:17.030364+0800 YSC-GCD-demo[20008:5024757] asyncSerial---end

2018-02-23 20:41:19.035379+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}

2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}

2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}

2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}

2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}

2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}

在异步执行 + 串行队列可以看到：

* 开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。

* 所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。

* 任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

下边讲讲刚才我们提到过的特殊队列：主队列。

* 主队列：GCD自带的一种特殊的串行队列

    * 所有放在主队列中的任务，都会放到主线程中执行

    * 可使用dispatch_get_main_queue()获得主队列

/**

* 同步执行 + 主队列

* 特点(主线程调用)：互等卡主不执行。

* 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。

*/

- (void)syncMain {


    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"syncMain---begin");


    dispatch_queue_t queue = dispatch_get_main_queue();


    dispatch_sync(queue, ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_sync(queue, ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_sync(queue, ^{

        // 追加任务3

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    NSLog(@"syncMain---end");

}

输出结果

2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread---{number = 1, name = main}

2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] syncMain---begin

(lldb)

在同步执行 + 主队列可以惊奇的发现：

* 在主线程中使用同步执行 + 主队列，追加到主线程的任务1、任务2、任务3都不再执行了，而且syncMain---end也没有打印，在XCode 9上还会报崩溃。这是为什么呢？

这是因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕，才能接着执行。

那么，现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。

 要是如果不在主线程中调用，而在其他线程中调用会如何呢？

// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行

selector 任务

[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

输出结果：

2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread---{number = 3, name = (null)}

2018-02-23 20:44:19.377494+0800 YSC-GCD-demo[20083:5040347] syncMain---begin

2018-02-23 20:44:21.384716+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}

2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}

2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}

2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}

2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}

2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}

2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain---end

在其他线程中使用同步执行 + 主队列可看到：

* 所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。

* 所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行（同步任务需要等待队列的任务执行结束）。

* 任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

为什么现在就不会卡住了呢？

因为syncMain 任务放到了其他线程里，而任务1、任务2、任务3都在追加到主队列中，这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2、任务3。所以这里不会卡住线程。


/**

* 异步执行 + 主队列

* 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务

*/

- (void)asyncMain {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"asyncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

   dispatch_async(queue, ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_async(queue, ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    dispatch_async(queue, ^{

        // 追加任务3

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    NSLog(@"asyncMain---end");

}

输出结果：

2018-02-23 20:45:49.981505+0800 YSC-GCD-demo[20111:5046708] currentThread---{number = 1, name = main}

2018-02-23 20:45:49.981935+0800 YSC-GCD-demo[20111:5046708] asyncMain---begin

2018-02-23 20:45:49.982352+0800 YSC-GCD-demo[20111:5046708] asyncMain---end

2018-02-23 20:45:51.991096+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}

2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}

2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}

2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}

2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}

2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}

在异步执行 + 主队列可以看到：

* 所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。

* 所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。

* 任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。


线程通信：

简单通信：耗时操作放入子线程，然后再次回到主线程

/**

* 线程间通信

*/

- (void)communication {

    // 获取全局并发队列

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

    // 获取主队列

dispatch_queue_t mainQueue = dispatch_get_main_queue(); 


    dispatch_async(queue, ^{

        // 异步追加任务

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

        // 回到主线程

        dispatch_async(mainQueue, ^{

            // 追加在主线程中执行的任务

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        });

    });

}

输出结果：

2018-02-23 20:47:03.462394+0800 YSC-GCD-demo[20154:5053282] 1---{number = 3, name = (null)}

2018-02-23 20:47:05.465912+0800 YSC-GCD-demo[20154:5053282] 1---{number = 3, name = (null)}

2018-02-23 20:47:07.466657+0800 YSC-GCD-demo[20154:5052953] 2---{number = 1, name = main}

栅栏通信：dispatch_barrier_async（注意栅栏通信只在自己定义的并行队列中有作用，是不能再系统队列中操作的。如globalQueue）

/**

* 栅栏方法 dispatch_barrier_async

*/

- (void)barrier {

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);


    dispatch_async(queue, ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    dispatch_async(queue, ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_barrier_async(queue, ^{

        // 追加任务 barrier

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程

        }

    });


    dispatch_async(queue, ^{

        // 追加任务3

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

    dispatch_async(queue, ^{

        // 追加任务4

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });

}

输出结果：

2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059274] 1---{number = 4, name = (null)}

2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059273] 2---{number = 3, name = (null)}

2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059274] 1---{number = 4, name = (null)}

2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059273] 2---{number = 3, name = (null)}

2018-02-23 20:48:22.306290+0800 YSC-GCD-demo[20188:5059274] barrier---{number = 4, name = (null)}

2018-02-23 20:48:24.311655+0800 YSC-GCD-demo[20188:5059274] barrier---{number = 4, name = (null)}

2018-02-23 20:48:26.316943+0800 YSC-GCD-demo[20188:5059273] 4---{number = 3, name = (null)}

2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3---{number = 4, name = (null)}

2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4---{number = 3, name = (null)}

2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3---{number = 4, name = (null)}

在dispatch_barrier_async执行结果中可以看出：

在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。有效的组织了线程执行顺序

延迟执行：dispatch_after

在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。

需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

   NSLog(@"currentThread:%@",[NSThread currentThread]);

    NSLog(@"asyncMain--begin");

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        NSLog(@"after---%@",[NSThread currentThread]);  // 打印当前线程

    });

    NSLog(@"asyncMain--end");

2018-04-17 12:11:10.370618+0800 PerformanceDemo[6937:8252947] asyncMain--begin

2018-04-17 12:11:10.370618+0800 PerformanceDemo[6937:8252947] asyncMain--end

2018-04-17 12:11:15.370575+0800 PerformanceDemo[6937:8252947] after---{number = 1, name = main}

结果可以看到，atter5秒后才被执行，但是end优先结束了，因为它5秒后才被放入的朱队列。而不是执行


线程保障方法只执行一次 dispatch_once

创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用

dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。

/**

* 一次性代码（只执行一次）dispatch_once

*/

- (void)once {

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{

        // 只执行1次的代码(这里面默认是线程安全的)

    });

}


dispatch_apply替代for循环 执行一个方法多次

dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。

利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。

还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

/**

* 快速迭代方法 dispatch_apply

*/

- (void)apply {

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);


    NSLog(@"apply---begin");

    dispatch_apply(6, queue, ^(size_t index) {

        NSLog(@"%zd---%@",index, [NSThread currentThread]);

    });

    NSLog(@"apply---end");

}

输出结果：

2018-02-23 22:03:18.475499+0800 YSC-GCD-demo[20470:5176805] apply---begin

2018-02-23 22:03:18.476672+0800 YSC-GCD-demo[20470:5177035] 1---{number = 3, name = (null)}

2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0---{number = 1, name = main}

2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2---{number = 4, name = (null)}

2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3---{number = 5, name = (null)}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4---{number = 3, name = (null)}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5---{number = 1, name = main}

2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] apply—end

可以看到 虽然在异步队列中，它并么有因为并发操作而不阻塞主线程，但是顺序无法保障了

线程组通信

有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合 来实现

dispatch_group_async。

调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。

dispatch_group_notify

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。注意它异步不阻塞当前线程

/**

* 队列组 dispatch_group_notify

*/

- (void)groupNotify {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"group---begin");


    dispatch_group_t group =  dispatch_group_create();


    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_group_notify(group, dispatch_get_main_queue(), ^{

        // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

        NSLog(@"group---end");

    });

     NSLog(@“bellow group—mainthread——continue");

}

输出结果：

2018-02-23 22:05:03.790035+0800 YSC-GCD-demo[20494:5183349] currentThread---{number = 1, name = main}

2018-02-23 22:05:03.790237+0800 YSC-GCD-demo[20494:5183349] group—begin

2018-02-23 22:05:03.790237+0800 YSC-GCD-demo[20494:5183349] bellow group—mainthread——continue

2018-02-23 22:05:05.792721+0800 YSC-GCD-demo[20494:5183654] 1---{number = 4, name = (null)}

2018-02-23 22:05:05.792725+0800 YSC-GCD-demo[20494:5183656] 2---{number = 3, name = (null)}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183656] 2---{number = 3, name = (null)}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183654] 1---{number = 4, name = (null)}

2018-02-23 22:05:09.798717+0800 YSC-GCD-demo[20494:5183349] 3---{number = 1, name = main}

2018-02-23 22:05:11.799827+0800 YSC-GCD-demo[20494:5183349] 3---{number = 1, name = main}

2018-02-23 22:05:11.799977+0800 YSC-GCD-demo[20494:5183349] group---end

从dispatch_group_notify相关代码运行输出结果可以看出：

当所有任务都执行完成之后，才执行dispatch_group_notify block 中的任务。

dispatch_group_wait

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

/**

* 队列组 dispatch_group_wait

*/

- (void)groupWait {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"group---begin");


    dispatch_group_t group =  dispatch_group_create();


    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

    });


// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）如果没有wait，本身不会阻塞当前线程继续执行

    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);


    NSLog(@"group---end");

}

输出结果：

2018-02-23 22:10:16.939258+0800 YSC-GCD-demo[20538:5198871] currentThread---{number = 1, name = main}

2018-02-23 22:10:16.939455+0800 YSC-GCD-demo[20538:5198871] group---begin

2018-02-23 22:10:18.943862+0800 YSC-GCD-demo[20538:5199137] 2---{number = 4, name = (null)}

2018-02-23 22:10:18.943861+0800 YSC-GCD-demo[20538:5199138] 1---{number = 3, name = (null)}

2018-02-23 22:10:20.947787+0800 YSC-GCD-demo[20538:5199137] 2---{number = 4, name = (null)}

2018-02-23 22:10:20.947790+0800 YSC-GCD-demo[20538:5199138] 1---{number = 3, name = (null)}

2018-02-23 22:10:20.948134+0800 YSC-GCD-demo[20538:5198871] group---end

从dispatch_group_wait相关代码运行输出结果可以看出：当所有任务执行完成之后，才执行 dispatch_group_wait之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程。


dispatch_group_enter、dispatch_group_leave组合使用

dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1

dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。

当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。

/**

* 队列组 dispatch_group_enter、dispatch_group_leave

*/

- (void)groupEnterAndLeave

{

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"group---begin");


    dispatch_group_t group = dispatch_group_create();

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_group_enter(group); //告知有一个任务啦 任务数量+1

    dispatch_async(queue, ^{

        // 追加任务1

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        }

dispatch_group_leave(group);//告知有一个任务执行完毕 任务数量-1

    });


dispatch_group_enter(group);//告知有一个任务执行完毕 任务数量+1

    dispatch_async(queue, ^{

        // 追加任务2

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        }

dispatch_group_leave(group);//告知有一个任务执行完毕 任务数量-1

    });


 //+1 +1 两次操作其实相当于两个异步任务加入了当前线程组 执行完毕后。继续后续操作。。。

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{

        // 等前面的异步操作都执行完毕后，回到主线程.

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

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        }

        NSLog(@"group---end");

    });


//    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）

//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

//

//    NSLog(@"group---end");

}

输出结果：

2018-02-23 22:14:17.997667+0800 YSC-GCD-demo[20592:5214830] currentThread---{number = 1, name = main}

2018-02-23 22:14:17.997839+0800 YSC-GCD-demo[20592:5214830] group---begin

2018-02-23 22:14:20.000298+0800 YSC-GCD-demo[20592:5215094] 1---{number = 4, name = (null)}

2018-02-23 22:14:20.000305+0800 YSC-GCD-demo[20592:5215095] 2---{number = 3, name = (null)}

2018-02-23 22:14:22.001323+0800 YSC-GCD-demo[20592:5215094] 1---{number = 4, name = (null)}

2018-02-23 22:14:22.001339+0800 YSC-GCD-demo[20592:5215095] 2---{number = 3, name = (null)}

2018-02-23 22:14:24.002321+0800 YSC-GCD-demo[20592:5214830] 3---{number = 1, name = main}

2018-02-23 22:14:26.002852+0800 YSC-GCD-demo[20592:5214830] 3---{number = 1, name = main}

2018-02-23 22:14:26.003116+0800 YSC-GCD-demo[20592:5214830] group—end

实际项目中一般封装了网络请求：；

dispatch_queue_t currentQueue = dispatch_queue_create("com.kevin.groupqueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_group_t group = dispatch_group_create();

    dispatch_group_async(group, currentQueue, ^{

        dispatch_group_enter(group);

        [FBFieldPayMainInfoRequest startRequestWithAppCode:self.appCode success:^(id response) {

            dispatch_group_leave(group);

            mainInfoResponse = response;

        } failure:^(NSError *error) {

            dispatch_group_leave(group);


        }];

    });

    dispatch_group_async(group, currentQueue, ^{

        dispatch_group_enter(group);

        [FBFieldPaymentPlanRequest startRequestWithAppCode:self.appCode success:^(id response) {

            dispatch_group_leave(group);

            listInfoResponse = response;

        } failure:^(NSError *error) {


        }];


    });

    dispatch_group_notify(group, currentQueue, ^{

        dispatch_async(dispatch_get_main_queue(), ^{

            [self configMainInfoData:mainInfoResponse listInfoData:listInfoResponse];

            [self.tableView.fb_header endRefreshing];

        });

    });

实际这样的模式就可以

     异步

    dispatch_group_async(group, globleq, ^{

        

    })

    需要阻塞就加上

    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    异步执行完执行notify

    dispatch_group_notify(group, globleq, ^{

        NSLog(@"dispatch_group_notify");

    });

但是我们一般网络框架都进行了封装。无法直接使用dispatch_group_async。所以必须enter、leave如下模式：

    dispatch_group_enter(group);

    异步

    dispatch_async(globleq, ^{

        //耗时操作

        dispatch_group_leave(group);

    });

    需要阻塞就加上

    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    异步执行完执行notify

    dispatch_group_notify(group, globleq, ^{

    });

从dispatch_group_enter、dispatch_group_leave相关代码运行结果中可以看出：当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async。



Dispatch Semaphore 线程同步

信号量实现线程同步操作

我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {

    __block NSArray *tasks = nil;

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {

        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {

            tasks = dataTasks;

        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {

            tasks = uploadTasks;

        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {

            tasks = downloadTasks;

        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {

            tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];

        }

        dispatch_semaphore_signal(semaphore);

    }];

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    return tasks;

}

下面，我们来利用 Dispatch Semaphore 实现线程同步，将异步执行任务转换为同步执行任务。

/**

* semaphore 线程同步

*/

- (void)semaphoreSync {


    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"semaphore---begin");


    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);


    __block int number = 0;

    dispatch_async(queue, ^{

        // 追加任务1

        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程


        number = 100;


        dispatch_semaphore_signal(semaphore);

    });


    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    NSLog(@"semaphore---end,number = %zd",number);

}

输出结果：

2018-02-23 22:22:26.521665+0800 YSC-GCD-demo[20642:5246341] currentThread---{number = 1, name = main}

2018-02-23 22:22:26.521869+0800 YSC-GCD-demo[20642:5246341] semaphore---begin

2018-02-23 22:22:28.526841+0800 YSC-GCD-demo[20642:5246638] 1---{number = 3, name = (null)}

2018-02-23 22:22:28.527030+0800 YSC-GCD-demo[20642:5246341] semaphore---end,number = 100

从 Dispatch Semaphore 实现线程同步的代码可以看到：

semaphore---end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。这是因为异步执行不会做任何等待，可以继续执行任务。

执行顺如下：

semaphore 初始创建时计数为 0。

异步执行将任务 1 追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法，semaphore 减 1，此时 semaphore == -1，当前线程进入等待状态。

然后，异步任务 1 开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量加1，此时 semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。

最后打印semaphore---end,number = 100。

这样就实现了线程同步，将异步执行任务转换为同步执行任务。

线程安全（使用 semaphore 加锁）

考虑线程安全的代码：

/**

* 线程安全：使用 semaphore 加锁

* 初始化火车票数量、卖票窗口(线程安全)、并开始卖票

*/

- (void)initTicketStatusSave {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程

    NSLog(@"semaphore---begin");


    semaphoreLock = dispatch_semaphore_create(1);


    self.ticketSurplusCount = 50;


    // queue1 代表北京火车票售卖窗口

    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);

    // queue2 代表上海火车票售卖窗口

    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);


    __weak typeof(self) weakSelf = self;

    dispatch_async(queue1, ^{

        [weakSelf saleTicketSafe];

    });


    dispatch_async(queue2, ^{

        [weakSelf saleTicketSafe];

    });

}

/**

* 售卖火车票(线程安全)

*/

- (void)saleTicketSafe {

    while (1) {

        // 相当于加锁

        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);


        if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖

            self.ticketSurplusCount--;

            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);

            [NSThread sleepForTimeInterval:0.2];

        } else { //如果已卖完，关闭售票窗口

            NSLog(@"所有火车票均已售完");


            // 相当于解锁

            dispatch_semaphore_signal(semaphoreLock);

            break;

        }


        // 相当于解锁

        dispatch_semaphore_signal(semaphoreLock);

    }

}

输出结果为：

2018-02-23 22:32:19.814232+0800 YSC-GCD-demo[20862:5290531] currentThread---{number = 1, name = main}

2018-02-23 22:32:19.814412+0800 YSC-GCD-demo[20862:5290531] semaphore---begin

2018-02-23 22:32:19.814837+0800 YSC-GCD-demo[20862:5290687] 剩余票数：49 窗口：{number = 3, name = (null)}

2018-02-23 22:32:20.017745+0800 YSC-GCD-demo[20862:5290689] 剩余票数：48 窗口：{number = 4, name = (null)}

2018-02-23 22:32:20.222039+0800 YSC-GCD-demo[20862:5290687] 剩余票数：47 窗口：{number = 3, name = (null)}

...

2018-02-23 22:32:29.024817+0800 YSC-GCD-demo[20862:5290689] 剩余票数：4 窗口：{number = 4, name = (null)}

2018-02-23 22:32:29.230110+0800 YSC-GCD-demo[20862:5290687] 剩余票数：3 窗口：{number = 3, name = (null)}

2018-02-23 22:32:29.433615+0800 YSC-GCD-demo[20862:5290689] 剩余票数：2 窗口：{number = 4, name = (null)}

2018-02-23 22:32:29.637572+0800 YSC-GCD-demo[20862:5290687] 剩余票数：1 窗口：{number = 3, name = (null)}

2018-02-23 22:32:29.840234+0800 YSC-GCD-demo[20862:5290689] 剩余票数：0 窗口：{number = 4, name = (null)}

2018-02-23 22:32:30.044960+0800 YSC-GCD-demo[20862:5290687] 所有火车票均已售完

2018-02-23 22:32:30.045260+0800 YSC-GCD-demo[20862:5290689] 所有火车票均已售完

可以看出，在考虑了线程安全的情况下，使用 dispatch_semaphore机制之后，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。


面试案例

NSURLConnection和NSURLSession差别

普通任务和上传

NSURLSession 针对下载/上传等复杂的网络操作提供了专门的解决方案，针对普通、上传和下载分别对应三种不同的网络请求任务：NSURLSessionDataTask，NSURLSessionUploadTask 和 NSURLSessionDownloadTask。创建的 task 都是挂起状态，需要 resume 才能启动。

当服务器返回的数据较小时，NSURLSession 与 NSURLConnection 执行普通任务的操作步骤没有区别。

执行上传任务时，NSURLSession 与 NSURLConnection 一样需要设置 POST 请求的请求体进行上传。

下载任务方式

NSURLConnection下载文件时，先是将整个文件下载到内存，然后再写入到沙盒，如果文件比较大，就会出现内存暴涨的情况。

而使用 NSURLSessionDownloadTask 下载文件，会默认下载到沙盒中的 tmp 文件中，不会出现内存暴涨的情况，但是在下载完成后会把 tmp 中的临时文件删除，需要在初始化任务方法时，在 completionHandler 回调中增加保存文件的代码。

请求方法的控制

NSURLConnection 实例化对象，实例化开始，默认请求就发送(同步发送)，不需要调用 start 方法。而 cancel 可以停止请求的发送，停止后不能继续访问，需要创建新的请求。

NSURLSession 有三个控制方法，取消(cancel)、暂停(suspend)、继续(resume)，暂停以后可以通过继续恢复当前的请求任务。

断点续传的方式

NSURLConnection 进行断点下载，通过设置访问请求的 HTTPHeaderField 的 Range 属性，开启运行循环，NSURLConnection 的代理方法作为运行循环的事件源，接收到下载数据时代理方法就会持续调用，并使用 NSOutputStream 管道流进行数据保存。

NSURLSession 进行断点下载，当暂停下载任务后，如果 downloadTask（下载任务）为非空，调用 cancelByProducingResumeData:(void (^)(NSData *resumeData))completionHandler 这个方法，这个方法接收一个参数，完成处理代码块，这个代码块有一个 NSData 参数 resumeData，如果 resumeData 非空，我们就保存这个对象到视图控制器的 resumeData 属性中，在点击再次下载时，通过调用[ [self.session downloadTaskWithResumeData:self.resumeData] resume]方法进行继续下载操作。

经过以上比较可以发现，使用 NSURLSession 进行断点下载更加便捷。

配置信息

NSURLSession 的构造方法sessionWithConfiguration:delegate:delegateQueue中有一个 NSURLSessionConfiguration 类的参数可以设置配置信息，其决定了 cookie，安全和高速缓存策略，最大主机连接数，资源管理，网络超时等配置。NSURLConnection 不能进行这个配置，相比较与 NSURLConnection 依赖与一个全局的配置对象，缺乏灵活性而言，NSURLSession 有很大的改进了。


线程案例： 

```

dispatch_semaphore 信号量demo 异步转同步

dispatch_semaphore_t s = dispatch_semaphore_create(1);

    dispatch_queue_t q = dispatch_queue_create("dsssqueue", DISPATCH_QUEUE_CONCURRENT);

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

        dispatch_async(q, ^{

            dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER);

            NSLog(@"%d---00000---%@",i,NSThread.currentThread);

            dispatch_semaphore_signal(s);

        });

    }


    NSLog(@"mid....");

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

        dispatch_async(q, ^{

            dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER);

            NSLog(@"1-----11111---%@",NSThread.currentThread);

            dispatch_semaphore_signal(s);

        });

    }

    NSLog(@"end....”);

print

2021-03-02 16:17:43.850928+0800 KKKThread[29041:3156398] mid....

2021-03-02 16:17:43.851088+0800 KKKThread[29041:3156398] end....

2021-03-02 16:17:43.851042+0800 KKKThread[29041:3156483] 0---00000---{number = 4, name = (null)}

2021-03-02 16:17:43.851324+0800 KKKThread[29041:3158082] 1---00000---{number = 21, name = (null)}

2021-03-02 16:17:43.852119+0800 KKKThread[29041:3158083] 2---00000---{number = 22, name = (null)}

2021-03-02 16:17:43.853374+0800 KKKThread[29041:3158084] 3---00000---{number = 23, name = (null)}

2021-03-02 16:17:43.853610+0800 KKKThread[29041:3156483] 5---00000---{number = 4, name = (null)}

2021-03-02 16:17:43.853939+0800 KKKThread[29041:3158085] 4---00000---{number = 24, name = (null)}

2021-03-02 16:17:43.854261+0800 KKKThread[29041:3158086] 6---00000---{number = 25, name = (null)}

2021-03-02 16:17:43.854507+0800 KKKThread[29041:3158087] 7---00000---{number = 26, name = (null)}

2021-03-02 16:17:43.854816+0800 KKKThread[29041:3158088] 8---00000---{number = 27, name = (null)}

2021-03-02 16:17:43.855026+0800 KKKThread[29041:3158089] 9---00000---{number = 28, name = (null)}

2021-03-02 16:17:43.855461+0800 KKKThread[29041:3158090] 1-----11111---{number = 29, name = (null)}

2021-03-02 16:17:43.856047+0800 KKKThread[29041:3158082] 1-----11111---{number = 21, name = (null)}

2021-03-02 16:17:43.911037+0800 KKKThread[29041:3158091] 1-----11111---{number = 30, name = (null)}

2021-03-02 16:17:43.911237+0800 KKKThread[29041:3158092] 1-----11111---{number = 31, name = (null)}

2021-03-02 16:17:43.911392+0800 KKKThread[29041:3158093] 1-----11111---{number = 32, name = (null)}

2021-03-02 16:17:43.911565+0800 KKKThread[29041:3158094] 1-----11111---{number = 33, name = (null)}

2021-03-02 16:17:43.911738+0800 KKKThread[29041:3158095] 1-----11111---{number = 34, name = (null)}

2021-03-02 16:17:43.911890+0800 KKKThread[29041:3158096] 1-----11111---{number = 35, name = (null)}

2021-03-02 16:17:43.912049+0800 KKKThread[29041:3158097] 1-----11111---{number = 36, name = (null)}

2021-03-02 16:17:43.912239+0800 KKKThread[29041:3158098] 1-----11111---{number = 37, name = (null)}

信号量使用注意事项 释放时候信号量值大于等于初始化值

    dispatch_semaphore_t sig = dispatch_semaphore_create(1);

            dispatch_semaphore_t sig1 = dispatch_semaphore_create(1);

            dispatch_semaphore_t sig2 = dispatch_semaphore_create(1);


            dispatch_async(queue, ^{

                dispatch_semaphore_wait(sig, DISPATCH_TIME_FOREVER);

                [self testA];

                dispatch_semaphore_signal(sig);

            });

            dispatch_async(queue, ^{

                dispatch_semaphore_wait(sig1, DISPATCH_TIME_FOREVER)；

                [self testB];

                dispatch_semaphore_signal(sig1);

            });

            dispatch_async(queue, ^{

                dispatch_semaphore_wait(sig2, DISPATCH_TIME_FOREVER);

                [NSThread sleepForTimeInterval:1];

                [self testC];

                dispatch_semaphore_signal(sig2);

            });



            dispatch_async(queue, ^{

                dispatch_semaphore_wait(sig, DISPATCH_TIME_FOREVER);

                dispatch_semaphore_wait(sig1, DISPATCH_TIME_FOREVER);

                 ;

                dispatch_semaphore_wait(sig2, DISPATCH_TIME_FOREVER);

                NSLog(@" --- end -=---");


                //如果执行到此刻释放。信号量值为0.。直接崩溃了。。。EXC_BAD_INSTRUCTION 崩溃

                dispatch_semaphore_signal(sig);

                dispatch_semaphore_signal(sig1);

                dispatch_semaphore_signal(sig2);

            });

```

你可能感兴趣的:(IOS多线程)

  • 【iOS】GCD详解 cheng_lin0201 OCiOSiosobjective-c
    初识GCD深入理解GrandCentralDispatch(GCD)：iOS多线程编程的利器前言1.GCD简介1.1什么是GCD？1.2为什么使用GCD？2.GCD的核心概念2.1任务与队列2.2串行队列与并发队列3.GCD的API3.1DispatchQueue3.2dispatch_queue_create3.3MainDispatchQueue&GlobalDispatchQueue3.4d
  • iOS多线程基础 星辰流转轮回
    什么是进程?进程是指系统中正在运行的一个程序,每个进程间是独立的,每个进程均运行在其专用且受保护的内存空间内.什么是线程?一个进程想要执行任务,必须得有线程.(每一个进程至少要有一个线程)一个进程中的所有任务都在线程中执行线程的串行一个线程中的所有任务的执行顺序都是串行的,也就是说,在同一时间内,一个线程只能执行一个任务.只有执行完上一个任务才可以执行下一个;也可以任务,线程是进程中的一条执行路径
  • iOS多线程——概念与原理 iOS发呆君
    1.进程的定义进程是指在系统中正在运行的一个应用程序，在iOS系统中，每个进程之间都是独立的，每个进程都运行在其专用的且受保护的内存中。作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：196800191，加群密码：112233，不管你是小白还是大牛欢迎入驻，分享BAT,阿里面试题、面试经验，讨论技术，大家一起交流学习成长！2.线程的定义线程是进程的基本执行单元，一
  • iOS多线程 - 死锁原因 L域
    Note:在同一个串行队列中执行同步操作会引发死锁。-(void)viewdidLoad{//在主线程中进行同步操作（主线程）dispatch_sync(dispatch_get_main_queue(),^{//dosomething});}要知道死锁的原因，首先要清楚并发、串行队列，异步和同步之间的区别：并发队列将任务(函数)分配到线程执行时，不需要等待函数的返回即可执行下一个任务串行队列需要
  • iOS多线程详解 爱看书de图图
      在iOS开发中，我们经常会使用到多线程技术，用于处理一些比较耗时的操作。在iOS中，有四种多线程的API，接下来我会带领大家一起去了解一下多线程相关的知识，以便帮助大家更好的使用多线程编程。下面先看一下四种API的比较：iOS中常见的多线程方案pthread：基于C语言，可以跨平台使用，需要程序员管理生命周期，使用难度大，所以不怎么使用NSThread：基于OC，面向对象，操作简单，需要程序员
  • 重温01-iOS多线程编程 那月无痕
    OC中的多线程OC中多线程根据封装程度可以分为三个层次：NSThread、GCD和NSOperation，另外由于OC兼容C语言，因此仍然可以使用C语言的POSIX接口来实现多线程，只需引入相应的头文件：#includeNSThreadNSThread是封装程度最小最轻量级的，使用更灵活，但要手动管理线程的生命周期、线程同步和线程加锁等，开销较大；NSThread的基本使用比较简单，可以动态创建初
  • iOS面试—0、技术点 weixin_30919235 面试runtimeswift
    初级：先简单自我介绍一下自己聊一聊过往项目中你觉得收获最大的一个模块。运行时：https://juejin.im/post/5ac0a6116fb9a028de44d717#heading-19多线程：iOS多线程：『pthread、NSThread』详尽总结iOS多线程：『GCD』详尽总结iOS多线程：『NSOperation、NSOperationQueue』详尽总结viewcontrolle
  • iOS多线程同步异步、串行并发浅析 guoguojianshu
    先来说一个队列和任务：队列分为串行队列与并行队列任务的执行分为同步执行与异步执行这两两组合就成为了串行队列同步执行，串行队列异步执行，并行队列同步执行，并行队列异步执行而异步是多线程的代名词，异步在实际引用中会开启新的线程，执行耗时操作。那我们先来知道一个非常重要的事情：1.队列只是负责任务的调度，而不负责任务的执行2.任务是在线程中执行的队列和任务的特点：队列的特点：先进先出，排在前面的任务最先
  • NSOperation queue? 小小鱼类
    存放NSOperation的集合类。操作和操作队列，基本可以看成java中的线程和线程池的概念。用于处理ios多线程开发的问题。网上部分资料提到一点是，虽然是queue，但是却并不是带有队列的概念，放入的操作并非是按照严格的先进现出。这边又有个疑点是，对于队列来说，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的，但是Bfunc是等Afunc完全操作完
  • iOS多线程-RunLoop rainbowboy
    1、概念RunLoop与线程关联的，是一种事件处理环，用来安排和协调到来的事件，目的就是让其关联的线程在有事件到达时时刻保持运行状态，而当没有事件需要处理时进入睡眠状态从而节约资源，每一个线程都可以有一个RunLoop对象与之对应，并且是在第一次获取它是系统自动创建的，比如主线程关联的RunLoop，我们都知道程序的入口函数是main函数，下面是创建工程后Xcode自动生成的main.m文件的ma
  • 浅谈一种规避iOS多线程Crash的方案 酷爽 iOS
    一般来说，多线程编程因具有以下几个优点，一直被广泛应用：资源利用率更好程序设计在某些情况下更简单程序响应更快但是因为多线程而导致的crash问题，也是令程序员非常头疼的一个问题，因为线程调度执行顺序的不确定性，造成了crash一般都是小概率出现，在开发测试阶段很难发现，而一旦上线面对用户，造成的影响却是不容小觑的。一、Crash的场景有一种特别常见的会造成crash的场景为：多线程读写可变数组/字
  • GCD实现线程同步的方法 爱笑的猫mi
    在iOS多线程中我们知道NSOperationQueue操作队列可以直接使用addDependency函数设置操作之间的依赖关系实现线程同步，还可以使用setMaxConcurrentOperationCount函数直接设置最大并发数量。那么在GCD中又是如何实现线程同步和控制最大并发数量的呢？事实上在之前的问题中我们已经提到了GCD实现线程同步的两种方法了，一种是组队列（dispatch_gro
  • iOS多线程学习小记『GCD的API之dispatch_suspend/dispatch_resume』 达若漠沙
    3.2.10dispatch_suspend/dispatch_resume当追加大量处理到DispatchQueue时,在追加处理的过程中，有时希望不执行已追加的处理。例如验算结果被Block截获时，一些处理会对这个验算结果造成影响。在这种情况下，只要挂起DispatchQueue即可。当可以执行时再恢复。dispatch_suspend函数挂起指定的DispatchQueue.dispatch
  • IOS - @synchronized详解 Typeco
    本文首发于个人博客在IOS开发中，同步锁相信大家都使用过，即@synchronized,这篇文章向大家介绍一些@synchronized的原理和使用。@synchronized原理@synchronized是IOS多线程同步中性能最差的:却是使用起来最方便的一个，通常我们这么用：@synchronized(self){//code}为了了解其底层是如何实现的，我们在测试工程的ViewControl
  • iOS多线程之超实用理论+demo演示（可下载） Dast1Woop
    [toc]背景简介在初学iOS相关知识过程中，大多都对多线程有些恐惧的心里，同时感觉工作中用上的概率不大。但是如果平时不多积累并学透多线程，当工作中真的需要用到的时候，就很可能简单百度后把一些知识点稀里糊涂地就用到工作中了，殊不知里面有很多的坑，也有很多技巧需要在理论上先做了解，再结合实战，进一步去体会多线程的魅力和强大。接下来，就对多线程来源的背景进行简单的介绍：在计算的早期，计算机可以执行的最
  • 多线程基础 浪的出名
    什么是线程、多线程？在学习iOS多线程应用之前，我们先来学习一下什么是线程？线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程的实际运作单位，一条线程指的是进程中一个单一顺序的控制流。系统中正在运行的每一个应用程序都是一个进程，系统会为每个进程分配独立的内存空间。而一个进程中的所有任务都是在线程中执行的，因此每个进程至少得有一个线程，这也就是我们平常所说的主线程。一个进程可以开启
  • iOS多线程之pthread的简单使用 Mr_fei
    前言pthread是c语言编写的,基本用不到,了解一下就好.线程创建代码第一步:先导入#import第二步:创建线程//参数一:线程地址//参数二:线程属性//参数三:指向函数的指针//参数四:函数参数pthread_tpthread;pthread_create(&pthread,NULL,test,NULL);void*(test)(void*param){NSLog(@"%@",[NSThr
  • iOS多线程编程 红太羊_8225
    OC中的多线程OC中多线程根据封装程度可以分为三个层次：NSThread、GCD和NSOperation，另外由于OC兼容C语言，因此仍然可以使用C语言的POSIX接口来实现多线程，只需引入相应的头文件：#include。NSThreadNSThread是封装程度最小最轻量级的，使用更灵活，但要手动管理线程的生命周期、线程同步和线程加锁等，开销较大；NSThread的基本使用比较简单，可以动态创建
  • iOS多线程——pthread、NSThread 不学会Core Data不改名 ioscocoamacosobjective-c
    pthreadNSThread多线程的常见方案pthreadpthread简介pthread使用方法pthread其他相关方法NSThread创建、启动线程线程相关用法线程状态控制方法线程之间的通信NSThread线程安全和线程同步NSThread非线程安全NSThread线程安全多线程的常见方案技术方案特点使用语言线程生命周期使用频率pthread一套通用的多线程API适用于Windows/Li
  • iOS 多线程 可地出溜
    前言：这可能是史上最全面的一篇iOS多线程博客了（王婆卖瓜一番），从多线程的基本概念，进程的概念，引出iOS中的四种多线程方案pthread、NSThread、NSOperation和GCD，每一部分都有详细的代码和解释说明；在GCD中，引出同步、异步、串行队列（包括主队列）和并发队列概念，并对他们的六种组合进行详细的代码验证和说明，把这些概念安排的明明白白，然后详细的说明了GCD常见的其他用法；
  • iOS多线程 雪丹妮_66865
    进程：进程是指在系统中正在运行的一个应用程序每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内线程：1个进程要想执行任务，必须得有线程(每1个进程至少要有1条线程)一个进程(程序)的所有任务都在线程中执行进程和线程的比较1.线程是CPU调用(执行任务)的最小单位2.进程是CPU分配资源和调度的单位3.一个程序可以对应多个进程，一个进程中可以有多个线程，但至少要有一个线程4.同一个进程
  • iOS多线程：『GCD』详尽总结 林希品
    行走的少年郎关注2016.09.0319:47*字数10492阅读41799评论91喜欢504image.png本文首发于我的个人博客：『不羁阁』文章链接：传送门本文更新时间：2018-02-2410:07:40感谢大家对这篇文章的喜欢和支持。为了不辜负大家的喜欢，也为了更好的让大家了解iOS多线程，以及GCD的相关知识，我对这篇文章进行了重新梳理，在原有文章的基础上修改了原文存在的问题，并增加了
  • iOS多线程-GCD的常见用法 学习天亦
    复习下线程的基础知识，这里主要是参考文顶顶多线程篇复习写的。1、线程间通信示例从子线程回到主线程#import"ViewController.h"@interfaceViewController()@property(strong,nonatomic)UIImageView*imageView;@end@implementationViewController-(void)viewDidLoad{
  • iOS多线程 - GCD中的栅栏函数 赑屃王者
    一、什么是栅栏函数dispatch_barrier_async函数，在进程管理中起到一个栅栏的作用，它等待所有位于barrier函数之前的操作执行完毕后执行,并且在barrier函数执行之后,barrier函数之后的操作才会得到执行，该函数需要同dispatch_queue_create函数生成的DISPATCH_QUEUE_CONCURRENT队列一起使用。二、dispatch_barrier_
  • 谈谈iOS多线程的锁 KingWorld
    image前言iOS开发中由于各种第三方库的高度封装，对锁的使用很少，刚好之前面试中被问到的关于并发编程锁的问题，都是一知半解，于是决定整理一下关于iOS中锁的知识，为大家查缺补漏。目录第一部分：什么是锁第二部分：锁的分类第三部分：性能对比第四部分：常见的死锁第五部分：总结(附Demo)正文一、什么是锁在过去几十年并发研究领域的出版物中，锁总是扮演着坏人的角色，锁背负的指控包括引起死锁、锁封护（l
  • iOS多线程(二) 大虾咪
    常见问题解惑1.问题一1.1以下代码打印结果-(void)viewDidLoad{[superviewDidLoad];dispatch_queue_tqueue=dispatch_queue_create("myqueue",DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue,^{NSLog(@"task1");[selfperformSelector
  • 472,iOS多线程NSOperation 与 GCD的区别(面试点：GCD 和 NSOperation的区别主要表现在以下几方面: 1) GCD是一套 C 语言API,执行和操作简单高效，因... 枫叶1234
    GCD和NSOperation的区别主要表现在以下几方面:1)GCD是一套C语言API,执行和操作简单高效，因此NSOperation底层也通过GCD实现，这是他们之间最本质的区别.因此如果希望自定义任务，建议使用NSOperation；依赖关系，NSOperation可以设置操作之间的依赖(可以跨队列设置)，GCD无法设置依赖关系，不过可以通过同步来实现这种效果；3)KVO(键值对观察)，NSO
  • iOS多线程之pthread CoderJay
    什么是pthreadPOSIX线程（POSIXthreads），简称Pthreads，是线程的POSIX标准。该标准定义了创建和操纵线程的一整套API。在类Unix操作系统（Unix、Linux、MacOSX等）中，都使用Pthreads作为操作系统的线程。pthread的使用一般情况在iOS开发中我们很少使用pthread来创建线程，pthread常见跨平台框架中多线程创建。pthread是c语
  • iOS多线程-NSOperation基本操作 学习天亦
    复习下线程的基础知识，这里主要是参考文顶顶多线程篇复习写的。一、并发数（1）并发数:同时执⾏行的任务数.比如,同时开3个线程执行3个任务,并发数就是3（2）最大并发数：同一时间最多只能执行的任务的个数。（3）最⼤大并发数的相关⽅方法-(NSInteger)maxConcurrentOperationCount;-(void)setMaxConcurrentOperationCount:(NSInt
  • iOS多线程的锁,你知道多少？ iOS__开发者皮皮峰
    前言iOS开发中由于各种第三方库的高度封装，对锁的使用很少，刚好之前面试中被问到的关于并发编程锁的问题，都是一知半解，于是决定整理一下关于iOS中锁的知识，为大家查缺补漏。目录第一部分：什么是锁第二部分：锁的分类第三部分：性能对比第四部分：常见的死锁第五部分：总结(附Demo)正文一、什么是锁在过去几十年并发研究领域的出版物中，锁总是扮演着坏人的角色，锁背负的指控包括引起死锁、锁封护（luyang
  • 基本数据类型和引用类型的初始值 3213213333332132 java基础
    package com.array; /** * @Description 测试初始值 * @author FuJianyong * 2015-1-22上午10:31:53 */ public class ArrayTest { ArrayTest at; String str; byte bt; short s; int i; long
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》 白糖_ 高质量代码
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。           看完整本书，也记了不少笔记
  • 【备忘】Django 常用命令及最佳实践 dongwei_6688 django
    注意：本文基于 Django 1.8.2 版本   生成数据库迁移脚本（python 脚本） python manage.py makemigrations polls  说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整   查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： python manage.p
  • 阶乘算法之一N! 末尾有多少个零 周凡杨 java算法阶乘面试效率
                                     &n
  • spring注入servlet g21121 Spring注入
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： ServletContext application = getServletContext(); WebApplicationContext wac = WebApplicationContextUtil
  • Jenkins 命令行操作说明文档 510888780 centos
    假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 基本的格式为 java 基本的格式为 java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 下面具体介绍各个命令的作用及基本使用方法 1. &nb
  • UnicodeBlock检测中文用法 布衣凌宇 UnicodeBlock
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
  • java下实现调用oracle的存储过程和函数 aijuans javaorale
    1.创建表：STOCK_PRICES     2.插入测试数据：     3.建立一个返回游标：  PKG_PUB_UTILS   4.创建和存储过程：P_GET_PRICE     5.创建函数：   6.JAVA调用存储过程返回结果集 JDBCoracle10G_INVO
  • Velocity Toolbox antlove 模板toolboxvelocity
    velocity.VelocityUtil package velocity; import org.apache.velocity.Template; import org.apache.velocity.app.Velocity; import org.apache.velocity.app.VelocityEngine; import org.apache.velocity.c
  • JAVA正则表达式匹配基础 百合不是茶 java正则表达式的匹配
      正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作   正则表达式的用途; 字符串的匹配 字符串的分割 字符串的查找 字符串的替换       正则表达式的验证语法     [a] //[]表示这个字符只出现一次 ,[a] 表示a只出现一
  • 是否使用EL表达式的配置 bijian1013 jspweb.xmlELEasyTemplate
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。         网
  • 精通Oracle10编程SQL(1-3)PLSQL基础 bijian1013 oracle数据库plsql
    --只包含执行部分的PL/SQL块 --set serveroutput off begin dbms_output.put_line('Hello,everyone!'); end; select * from emp; --包含定义部分和执行部分的PL/SQL块 declare v_ename varchar2(5); begin select
  • 【Nginx三】Nginx作为反向代理服务器 bit1129 nginx
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能：   接受客户端请求 将请求转发给被代理的服务器 从被代理的服务器获得响应结果 把响应结果返回给客户端 实例 本文把Nginx配置成一个简单的代理服务器 对于静态的html和图片，直接从Nginx获取 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin blackproof maven报错
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin   maven报错： Plugin execution not covered by lifecycle configuration:
  • 发布docker程序到marathon ronin47 docker 发布应用
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry docker pull docker-registry docker run -t -p 5000:5000 docker-registry 下载docker镜像并发布到私有registry docker pull consol/tomcat-8.0
  • java-57-用两个栈实现队列&&用两个队列实现一个栈 bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; /* * Q 57 用两个栈实现队列 */ public class QueueImplementByTwoStacks { private Stack<Integer> stack1; pr
  • Nginx配置性能优化 cfyme nginx
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605   大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术 comsci java
         对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件......   &nb
  • MonkeyRunner的使用 dai_lm androidMonkeyRunner
    要使用MonkeyRunner，就要学习使用Python，哎 先抄一段官方doc里的代码 作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 # Imports the monkeyrunner modules used by this program from com.android.monkeyrunner import MonkeyRun
  • Hadoop-- 海量文件的分布式计算处理方案 datamachine mapreducehadoop分布式计算
    csdn的一个关于hadoop的分布式处理方案，存档。 原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。     Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
  • 以資料庫驗證登入 dcj3sjt126com yii
    以資料庫驗證登入 由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
  • github做webhooks：[2]php版本自动触发更新 dcj3sjt126com githubgitwebhooks
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。 工具/原料 git github 方法/步骤   在github的setting里面的webhooks里把我们的url地址填进去。   钩子更新的代码如下： error_reportin
  • Eos开发常用表达式 蕃薯耀 Eos开发Eos入门Eos开发常用表达式
    Eos开发常用表达式 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2014年8月18日 15:03:35 星期一     &
  • SpringSecurity3.X--SpEL 表达式 hanqunfeng SpringSecurity
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性：   <http auto-config="true" use-expressions="true"> 这样就会在投票器中自动增加一个投票器：org.springframework
  • Redis vs Memcache IXHONG redis
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 3. Redis支持数据的备份，即master-slave模式的数据备份。 4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Red
  • Python - 装饰器使用过程中的误区解读 kvhur JavaScriptjqueryhtml5css
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 原文链接：http://www.gbtags.com/gb/share/5563.htm Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：   @function_wrapper de
  • 架构师之mybatis-----update 带case when 针对多种情况更新 nannan408 case when
    1.前言.    如题. 2. 代码.   <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="list" index=&
  • Algorithm算法视频教程 栏目记者 Algorithm算法
    课程：Algorithm算法视频教程 百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 一、课程内容： 课时1、算法的基本概念 + Sequential search 课时2、Binary search 课时3、Hash table 课时4、Algor
  • C语言算法之冒泡排序 qiufeihu c算法
    任意输入10个数字由小到大进行排序。 代码： #include <stdio.h> int main() { int i,j,t,a[11]; /*定义变量及数组为基本类型*/ for(i = 1;i < 11;i++){ scanf("%d",&a[i]); /*从键盘中输入10个数*/ } for
  • JSP异常处理 wyzuomumu Webjsp
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: <%@ page errorPage="errors.jsp"%>   2.在处理异常的网页中做如下声明： errors.jsp: <%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他