iOS 多线程浅述

时间：2016-04-22 19:29:36 阅读：284 评论：0 收藏：0 [点我收藏+]

标签：

什么是进程？

进程是指在系统中正在运行的一个应用程序。
每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。

什么是线程？

1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）。
线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行。

`小拓展`：

- 线程的串行（就像烤串一样）
    - 1个线程中任务的执行是串行的。
    - 如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务。
    - 在`同一时间内`，1个线程只能执行1个任务。

什么是多线程？

1个进程中可以开启多条线程，每条线程可以并行（同时）执行不同的任务。
线程的并行（同时执行）
- 比如同时开启3条线程分别下载3个文件（分别是文件A、文件B、文件C。
多线程并发执行的原理：
- 在同一时间里，CPU只能处理1条线程，只有1条线程在工作（执行）。
- 多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换），如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象。（如下图）

多线程优缺点：

优点
- 能适当提高程序的执行效率。
- 能适当提高资源利用率（CPU、内存利用率）
缺点
- 开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能。
- 线程越多，CPU在调度线程上的开销就越大。
- 程序设计更加复杂：比如线程之间的通信、多线程的数据共享

多线程在iOS开发中的应用

- 主线程
    - 一个iOS程序运行后，默认会在自己的进程中开启1条线程，称为“主线程”也叫“UI线程”。
    - 作用：刷新显示UI,处理UI事件。
- 使用注意
    - 不要将耗时操作放到主线程中去处理，因为会卡住主线程，造成UI卡顿（用户体验差）。
    - 和UI相关的刷新操作`必须`放到主线程中进行处理。

线程的状态

线程的各种状态：新建-就绪-运行-阻塞-死亡

常用的控制线程状态的方法

    [NSThread exit];//退出当前线程
    [NSThread sleepForTimeInterval:7.0];//阻塞线程
    [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:7.0]];//阻塞线程

`注意：线程死亡后不能复生`

线程安全：

前提：多个线程同时访问同一块资源会发生数据安全问题 解决方案：加互斥锁
相关代码：@synchronized(self){}
专业术语-线程同步
原子和非原子属性（是否对setter方法加锁）

IOS中多线程的实现方案

方案	简介	语言	线程生命周期	使用频率
pthread	一套通用的多线程API （跨平台\可移植）	C语言	程序员管理	几乎不用
`NSThread`	使用更加面向对象（简单易用，可直接操作线程对象）	OC语言	程序员管理	偶尔使用
`GCD`	为了替代NSThread为生（`充分利用设备多核`）	C语言	系统自动管理	经常使用
`NSOperation`	基于GCD （`更加面向对象更方便地设置线程之间的依赖监听线程状态KVO`）	OC语言	系统自动管理	经常使用

pthread简单使用

1.包含头文件（必须）

#import <pthread.h>

2.创建线程

//  创建线程
/**
     *
     * 参数一：线程对象（传地址）
     * 参数二：线程的属性（名称\优先级）
     * 参数三：只想函数的指针
     * 参数四：函数需要接受的字符串参数，可以不传递（注：由于我们创建的是OC的字符串，所以在传值的时候需要将其转换成C的字符串）
     */
    pthread_t thread;
    NSString *num = @"123";
    pthread_create(&thread, NULL, task, (__bridge void *)(num));

3.定义参数所需要的函数指针


void *task(void *num)
{
    NSLog(@"当前线程 -- %@,传入的参数：-- %@", [NSThread currentThread], num);

    return NULL;
}

如果需要退出线程的话只需调用下面代码

pthread_exit(NULL);

运行结果：
技术分享

NSThread简单使用

这边介绍NSThread创建线程的4种方式：

第一种 (alloc nitWithTarget:selector:object:)
- 特点：需要手动开启线程，可以拿到线程对象进行详细设置
- 优缺点：
  - 缺点：需要手动开启线程执行任务
  - 优点：可以拿到线程对象

//  创建线程
    /**
     * 参数一：目标对象
     * 参数二：方法选择器（线程启动后调用的方法）
     * 参数三：调用方法需要接受的参数
     */
    NSThread *thread = [[NSThread alloc] initWithTarget:self
                                               selector:@selector(task)
                                                 object:nil];

    //  开始执行
    [thread start];

第二种(分离出一条子线程)
- 特点：自动启动线程，无法对线程进行更详细的设置
- 优缺点：
  - 缺点：无法拿到线程对象进行更详细设置
  - 优点：代码简单且自动开启线程执行

//  创建线程
    /**
     * 参数一：要调用的方法
     * 参数二：目标对象 self
     * 参数三：调用方法需传递的参数
     */
    [NSThread detachNewThreadSelector:@selector(task)
                             toTarget:self
                           withObject:nil];

第三种（后台线程）
- 特点：自动启动线程，无法进行更详细设置
- 优缺点：
  - 缺点：无法拿到线程对象进行更详细设置
  - 优点：代码简单且自动开启线程执行


/**
 *  NSThread创建一条后台线程
 */
- (void)nsthreadTest3
{
    //  创建线程
    /**
     * 参数一：要调用的方法
     * 参数二：调用方法需传递的参数
     */
    [self performSelectorInBackground:@selector(run:) withObject:@"后台线程"];

}

- (void)run:(NSString *)str
{
    NSLog(@"当前线程：%@ -- 接收到的参数：%@", [NSThread currentThread], str);
}

第四种（自定义NSThread类并重写内部的方法实现）
- 特点：可以不暴露一些实现细节，使代码增加隐蔽性。（一般出现在第三方框架内）
- 优缺点：
  - 缺点：繁琐，且需要手动开启线程执行
  - 优点：增加代码隐蔽性

1.创建自定义类继承自NSThread
2.重写NSThread类中的main方法

- (void)main
{
    NSLog(@"当前线程--%@", [NSThread currentThread]);
}

3.创建线程对象

/**
 *  NSThread创建一条后台线程
 */
- (void)nsthreadTest4
{
    //  创建线程
    SJThread *thread = [[SJThread alloc] init];

    //  开启执行
    [thread start];
}

线程间通信

有时候我们会从服务器上下载图片然后再展示出来，下载的操作我们会放到子线程，而UI刷新的操作只能在主线程中执行。这样就涉及到线程间的通信。接下来我们分三种方式来简单实现一下：
- 方式一：

- (void)viewDidLoad {
    [super viewDidLoad];

    // 开启一条线程下载图片
    [NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];

}


- (void)downloadImage
{
    //  网络图片url
    NSURL *url = [NSURL URLWithString:@"http://img3.imgtn.bdimg.com/it/u=3841157212,2135341815&fm=206&gp=0.jpg"];
    //  根据url下载图片数据到本地
    NSData *imageData = [NSData dataWithContentsOfURL:url];
    //  把下载到本地的二进制数据转成图片
    UIImage *image = [UIImage imageWithData:imageData];
    //  回到主线程刷新UI
    //  第一种方式
    [self performSelectorOnMainThread:@selector(showImage:) withObject:image waitUntilDone:YES];

    //  第二种方式
    //  直接调用iconView里面的setImage：方法就可以实现刷新
//    [self.iconView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES];

    //  第三种方式
    //  此方法可以方便自由在主线程和其它线程切换
//    [self performSelector:@selector(showImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
}

- (void)showImage:(UIImage *)image
{
    self.iconView.image = image;
}

GCD简单使用

什么是GCD

GCD全称是Grand Central Dispatch（牛逼的中枢调度器）
纯C语言，提供了非常多强大的函数

GCD优势

GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核
GCD会自动关了线程生命周期（创建、调度、销毁线程）
GCD性能很好（接近底层）

GCD的组合方式

异步函数+并发队列：开启多条线程，并发执行任务
异步函数+串行队列：开启一条线程，串行执行任务
同步函数+并发队列：不开线程，串行执行任务
同步函数+串行队列：不开线程，串行执行任务
异步函数+主队列：不开线程，在主线程中串行执行任务
同步函数+主队列：不开线程，串行执行任务（注意死锁发生

`注意同步函数和异步函数在执行顺序上面的差异`

GCD的任务和队列

任务：执行什么操作
队列：用来存放任务（GCD中提供了2种队列）
- 串行队列
- 并发队列

GCD的使用

定制任务 —— 确定需要做的操作
将任务添加到队列中
GCD会自动将队列中的任务取出，存放到线程中执行
任务的取出遵循队列的FIFO原则（先进先出，后进后出）

技术分享

GCD创建线程

接下来看看同步函数和异步函数有什么区别：

1.先来看看异步并发队列

- (void)test
{
    /**
     * 参数一：C语言的字符串，给队列起一个名字或标识
     * 参数二：队列类型
        DISPATCH_QUEUE_CONCURRENT   并发
        DISPATCH_QUEUE_SERIAL   串行
     */
    dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);

    /**
     *  使用函数封装任务
     * 参数一：获取队列
     * 参数二：需要执行的任务
     */
    dispatch_async(queue, ^{
        NSLog(@"在：%@线程执行了任务",[NSThread currentThread]);
    });

    NSLog(@"结束");
}

执行结果：
技术分享

2.再来看看同步并发队列

- (void)test
{
    /**
     * 参数一：C语言的字符串，给队列起一个名字或标识
     * 参数二：队列类型
        DISPATCH_QUEUE_CONCURRENT   并发
        DISPATCH_QUEUE_SERIAL   串行（串行队列可以用NULL表示）
     */
    dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);

    /**
     *  使用函数封装任务
     * 参数一：获取队列
     * 参数二：需要执行的任务
     */
    dispatch_sync(queue, ^{
        NSLog(@"在：%@线程执行了任务",[NSThread currentThread]);
    });

    NSLog(@"结束");
}

执行结果：
技术分享

结论：

从上面的2个运行结果的时间可以看出
1.异步并发队列，会开启一条子线程来处理任务，以达到主线程和子线程同时执行的并发效果。
2.同步并发队列，不会开线程，必须等block块中的代码先执行完毕才会继续执行以外的任务，所以并发队列对于同步函数来说等同于“无效”

再看看并发队列对异步函数和同步函数的影响：

1.同步函数+并发队列

dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

执行结果：同步函数+并发队列没有开启子线程的能力

技术分享

2.异步函数+并发队列

- (void)test2
{
    dispatch_queue_t queue = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });
}

执行结果：异步函数+并发队列会自动开启3条子线程执行任务

技术分享

结论：

从上面可以看出，异步函数拥有开启子线程的能力，而同步函数没有开启子线程的能力。

GCD中，除了并发队列外，还有串行队列，我们来看看如果把并发队列换成串行队列会有怎样的变化

1.同步函数+串行队列

- (void)test2
{
    dispatch_queue_t queue = dispatch_queue_create("串行队列", DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });
}

执行结果：进一步证明同步函数没有开启子线程的能力，他的所有任务都在主线程中执行

技术分享

2.异步函数+串行队列

- (void)test2
{
    dispatch_queue_t queue = dispatch_queue_create("串行队列", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@",[NSThread currentThread]);
    });
}

执行结果：开启了一条子线程，在子线程中依次执行任务

技术分享

`结论`

1.在同步函数+串行队列中，任务依旧是在主线程中执行。

2.在异步函数+串行队列中，会自动开启一条子线程，在子线程中依次执行任务

3.再一次证明同步函数没有开启子线程的能力

系统提供的4个全局并发队列

在iOS中系统默认给我们提供了4个全局并发队列

- (void)test3
{
    //  获取全局并发队列
    //  系统内部默认提供4个全局并发队列
    /**
     * 参数一：优先级
     * 参数二：时间（传0即可）
     */
//优先级：DISPATCH_QUEUE_PRIORITY_HIGH 2
//      DISPATCH_QUEUE_PRIORITY_DEFAULT 0
//      DISPATCH_QUEUE_PRIORITY_LOW (-2)
//      DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN    级别最低

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(queue, ^{
        NSLog(@"1当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"2当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"3当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"4当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"5当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"6当前线程：%@", [NSThread currentThread]);
    });
}

执行结果：在结果中我们看到GCD创建了6条线程，但是实际上GCD创建多少条线程完全由系统当前情况而定，我们是无法控制的。

技术分享

特殊的串行队列 —— 主队列（与主线程相关联的队列）

主队列是GCD自带的一种特殊的串行队列
放在主队列中的人物，都会放到主线程中执行
使用dispatch_get_main_queue()的方式可获取主队列
- 特点
  - 1.放在主队列中的任务，必须在主线程中执行
  - 2.主队列执行任务的时候，在调度任务的时候，会先调用主线程的状态，如果当前有任务在做，则会等待主线程执行完任务再执行自己的任务

1.主队列+异步函数

- (void)test4
{
    //  获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    //  添加任务
    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });
}

执行结果：任务都在主线程中执行

技术分享

2.同步函数+主队列

- (void)test4
{
    //  获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    //  添加任务
    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });
}

执行结果：
进入死锁状态，因为主队列执行任务的时候，在调度任务的时候，会先调用主线程的状态，如果当前有任务在做，则会等待主线程执行完任务再执行自己的任务

`如果要解决以上的情况，那么可以将任务添加到子线程中，这样就不会出现死锁的情况，程序也就能够正常执行了`


[self performSelectorInBackground:@selector(test4) withObject:nil];

- (void)test4
{
    //  获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    //  添加任务
    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });

    dispatch_sync(queue, ^{
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    });
}

执行结果：

技术分享

`总结`

函数类型	并发队列	手动创建的串行队列	主队列
同步 (sync)	1.没有开启新线程 2.串行执行任务	1.有开启新线程 2.串行执行任务	死锁
异步（async）	1.有开启新线程 2.并发执行任务	1.有开启新线程 2.串行执行任务	1.没有开启新线程 2.串行执行任务

`注意`

使用sync函数往当前串行队列中添加任务，会卡主当前的串行队列。

GCD线程间的通信

有时候我们需要在子线程进行一些耗时操作，等耗时操作完成后再回到主线程进行相应的UI刷新，那么就可以使用下面的方式在子线程和主线程之间进行通信


- (void)test5
{
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    dispatch_async(queue, ^{

        NSLog(@"在%@线程中执行任务", [NSThread currentThread]);
        //  回到主线程
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"在%@线程中执行任务", [NSThread currentThread]);
        });
    });
}

执行结果：
技术分享

GCD延迟执行

特点：可以选择在哪个线程中执行任务

- (void)test6
{
    NSLog(@"方法开始运行");
    /**
     *  GCD延迟执行方法
     *
     *  参数一： 要延迟的时间 （以秒为单位）
     *  参数二： 在哪个线程中执行
     */
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"GCD定时器");
    });
}

执行结果：

技术分享

一次性代码

特点：
- 能保证整个程序运行过程中，block内的代码块只会被执行一次
- 线程是安全的
- 应用：简单的单例模式(单例模式实现点我)
- 注意点：不可放在懒加载中


- (void)test8
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"一次性代码运行");
    });
}

栅栏函数

作用：能够控制并发队列里面任务的执行顺序
注意：不能使用全局并发队列（会没有任何区别，文档中有注释——只对自己创建的并发队列有效）

- (void)test7
{
    //  创建队列
    dispatch_queue_t queue = dispatch_queue_create(0, 0);

    dispatch_async(queue, ^{

        for (int i = 0; i<5; i++) {
            NSLog(@"1");
        }
    });
    dispatch_async(queue, ^{

        for (int i = 0; i<5; i++) {
            NSLog(@"2");
        }
    });

    dispatch_barrier_async(queue, ^{
        NSLog(@"进入栅栏函数");
    });

    dispatch_async(queue, ^{
        for (int i = 0; i<5; i++) {
            NSLog(@"3");
        }
    });

    dispatch_async(queue, ^{
        for (int i = 0; i<5; i++) {
            NSLog(@"4");
        }
    });
}

执行结果：

技术分享

GCD迭代开发（遍历）

一般我们传统的遍历方式如下，它的缺点就是在处理比较耗时的操作时效率较低，因为只在一个线程中执行任务。

    //  传统的遍历方式
    for (int i ; i< 10; i++) {
        NSLog(@"%d -- 当前线程%@", i, [NSThread currentThread]);
    }

执行结果：
技术分享

在GCD中，为我们提供了一个迭代函数，可以开启子线程快速进行遍历，这样就可以大大提高效率,而且使用非常简单。接下来使用迭代函数来进行文件复制的操作：

- (void)test9
{
    //  获得文件原始路径(上层文件夹得路径)
    NSString *fromPath = @"/Users/yeshaojian/Desktop/test";

    //  获得文件的目标路径
    NSString *toPath = @"/Users/yeshaojian/Desktop/test2";

    //  得到文件路径下面的所有文件
    NSArray *subpaths =  [[NSFileManager defaultManager] subpathsAtPath:fromPath];
    NSLog(@"文件名：%@",subpaths);

    //  获取数组中文件的个数
    NSInteger count = subpaths.count;

    //  将要迭代的操作放到迭代函数内
    dispatch_apply(count, dispatch_get_global_queue(0, 0), ^(size_t index){
            //  拼接需要复制的文件的全路径
            NSString *fromFullpath = [fromPath stringByAppendingPathComponent:subpaths[index]];
            //  拼接目标目录的全路径
            NSString *toFullpath = [toPath stringByAppendingPathComponent:subpaths[index]];
            //  执行文件剪切操作
            /*
             * 参数一:文件在哪里的全路径
             * 参数二:文件要被剪切到哪里的全路径
             */
            [[NSFileManager defaultManager] moveItemAtPath:fromFullpath toPath:toFullpath error:nil];

           NSLog(@"拼接需要复制的文件的全路径：%@ -- 拼接目标目录的全路径：%@ -- 当前线程：%@",fromFullpath,toFullpath,[NSThread currentThread]);
       });

}

执行结果：
技术分享

队列组

假如开发中有多个任务，要求在所有任务都在子线程中并发执行，且不能使用栅栏函数，当所有任务都执行完成后打印“完成”。这样的需求就需要用到GCD中的队列组。
应用场合：
- 对多个任务有强制依赖性，缺一不可时使用

1.队列组的基本使用

- (void)test10
{
    // 获取队列组，用来管理队列
    dispatch_group_t group = dispatch_group_create();

    //  获取并发队列
    dispatch_queue_t queue = dispatch_queue_create("cs", DISPATCH_QUEUE_CONCURRENT);

    //  添加任务
    dispatch_group_async(group, queue, ^{
        NSLog(@"cs1---%@", [NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"cs2---%@", [NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"cs3---%@", [NSThread currentThread]);
    });

    //  拦截通知：当队列组中所有的任务都执行完毕后，会调用下面方法的block块
    dispatch_group_notify(group, queue, ^{
        NSLog(@"完成");
    });
}

执行结果：
技术分享

`队列组函数内部操作简要流程`

处理流程：
1.封装任务
2.把任务提交到队列
3.把当前任务的执行情况纳入到队列注的监听范围

注意：下面方法本身是异步的
dispatch_group_notify(group, queue, ^{

    });

拓展：
在一些框架或者早期项目中，可能会见到下面2种队列组的使用方法，在这边顺带提及一下，但不推荐使用，因为太过繁琐。

第一种

- (void)test11
{
    //  获得队列组,管理队列
    dispatch_group_t group = dispatch_group_create();

    //  获得并发队列
    dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);

    //  表示开始把后面的异步任务纳入到监听范围
    //dispatch_group_enter & dispatch_group_leave
    dispatch_group_enter(group);

    //  使用异步函数封装任务
    dispatch_async(queue, ^{
        NSLog(@"1---%@",[NSThread currentThread]);

        //  通知队列组该任务已经执行完毕
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"2---%@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"3---%@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });

    //  拦截通知
    dispatch_group_notify(group, queue, ^{
        NSLog(@"--完成---");
    });
}

第二种


- (void)test11
{
    //  获得队列组,管理队列
    dispatch_group_t group = dispatch_group_create();

    //  获得并发队列
    dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);

    //  表示开始把后面的异步任务纳入到监听范围
    //dispatch_group_enter & dispatch_group_leave
    dispatch_group_enter(group);

    //  使用异步函数封装任务
    dispatch_async(queue, ^{
        NSLog(@"1---%@",[NSThread currentThread]);

        //  通知队列组该任务已经执行完毕
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"2---%@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"3---%@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });

    //  等待DISPATCH_TIME_FOREVER 死等,一直要等到所有的任务都执行完毕之后才会继续往下执行
    //  同步执行
    dispatch_time_t timer = dispatch_time(DISPATCH_TIME_NOW, 0.00001 * NSEC_PER_SEC);

    //  等待timer m的时间 不管队列中的任务有没有执行完毕都继续往下执行,如果在该时间内所有事任务都执行完毕了那么会返回一个0,否则是非0值
    long n =  dispatch_group_wait(group, timer);
    NSLog(@"%ld",n);

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

补充：同步\异步函数另一种创建方式

其实同步函数和异步函数还有另外的创建方式，但是使用起来比较不方便，所以上面就没提及，想想还是补充一下好了

1.异步函数（创建一个使用函数封装代码的异步函数）

- (void)test12
{
    /**
     *  参数一：队列
     *  参数二：要传给函数的参数
     *  参数三：函数
     */
    dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, testTask);
}

void testTask(void *param)
{
    NSLog(@"%@", [NSThread currentThread]);
}

2.同步函数（创建一个使用函数封装代码的同步函数）

- (void)test12
{
    /**
     *  参数一：队列
     *  参数二：要传给函数的参数
     *  参数三：函数
     */
    dispatch_sync_f(dispatch_get_global_queue(0, 0), NULL, testTask);
}

void testTask(void *param)
{
    NSLog(@"%@", [NSThread currentThread]);
}

上面使用的是函数来封装要处理的代码，使用比较不方便，且block是轻量级的数据结构，更推荐使用block封装代码的形式创建同步\异步函数。

GCD一些需要注意的细节

全局并发队列是默认存在的（在我们程序运行的时候就存在）
全局队列根据队列的优先级分为（高，默认，低，后台优先级）4个并发队列
iOS 6之前，我们通过创建的线程，是要自己手动施放的
- 施放的方式 —— dispatch_release()
使用栅栏函数，苹果官方文档明确规定栅栏函数只有在和使用create函数创建的笔法队列一起使用才有效
暂时就想到这么多O(∩_∩)O，因为GCD已经开源，想研究的朋友可以到网上搜索一下，有哪里不对的可以联系我，谢谢！

NSOperation简单使用

NSOperation作用

配合使用NSOperation和NSOperationQueue也能实现多线程编程

NSOperation和NSOperationQueue实现多线程的具体步骤

先将需要执行的操作封装到一个NSOperation对象中
然后将NSOperation对象添加到NSOperation对象中
系统会自动将NSOperationQueue中的NSOperation取出来
将取出来的NSOperation封装的操作放到一条新线程中执行

NSOperation的子类

NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类
使用NSOperation子类的方式有3种
- NSInvocationOperation
- NSBlockOperation
- 自定义子类继承NSOperation,实现内部相应的方法

NSOperation封装操作

第一种方式 —— NSInvocationOperation

- (void)invocationTest
{
    /**
     * 参数一：目标对象
     * 参数二：调用方法
     */
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download) object:nil];

    //  开启任务
    [op1 start];
}

- (void)download
{
    NSLog(@"下载:%@",[NSThread currentThread]);
}

执行结果：需要和队列并用才会开启子线程执行任务
技术分享

第二种方式 —— Block

- (void)blockTest
{
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];

    [op1 addExecutionBlock:^{
        NSLog(@"增加的下载：%@", [NSThread currentThread]);
    }];

    //  开启任务
    [op1 start];
    [op2 start];
    [op3 start];
}

- (void)download
{
    NSLog(@"下载:%@",[NSThread currentThread]);
}

执行结果：如果一条线程中执行的操作大于1就会开启新线程并发执行
技术分享

方式三 —— 自定义NSOperation

1.先创建一个继承自NSOperation的类并重写main方法


- (void)main
{
    NSLog(@"当前线程：%@", [NSThread currentThread]);
}

2.在需要使用的类中引用自定义的类,并创建开启任务

- (void)custom
{
    SJOperation *op1 = [[SJOperation alloc] init];

    [op1 start];
}

执行结果：需要手动开启线程或者与队列并用才会开启子线程
技术分享

NSOperation中的队列

主队列（获取方式：+mainQueue）
- 所有在主队列中的任务都在主线程中执行
- 本质上是串行队列

- (void)invocationQueue
{
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];

    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download2) object:nil];

    NSInvocationOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download3) object:nil];

    //  获取主队列
    NSOperationQueue *queue = [NSOperationQueue mainQueue];

    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];

}

执行结果：所有任务都在主队列中执行，且是串行队列

技术分享

非主队列（获取方式：alloc init）
- 同时具备并发和串行功能
- 默认下是并发的

- (void)invocationQueue
{
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];

    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download2) object:nil];

    NSInvocationOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download3) object:nil];

    //  获取非主队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];

}

执行结果：所有任务在子线程中并发执行

技术分享

注意：addOperation:内部已经帮我们执行了开启任务方法，所有不需要另外实现。

NSBlockOperation与队列并用的简单写法

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    [queue addOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载:%@",[NSThread currentThread]);
    }];

执行结果：所有任务都在子线程中并发执行

技术分享

设置最大并发数

在NSOperation中，我们要想控制串行队列或者并发队列，只需要设置maxConcurrentOperationCount属性即可
- 一般我们要使用串行队列，只需设置值为1即可
- 如果值大于1，则为并发队列

1.串行队列示例

- (void)blockQueue
{
    //  创建非主队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    //  设置最大并发数为1，则队列为串行队列
    queue.maxConcurrentOperationCount = 1;

    [queue addOperationWithBlock:^{
        NSLog(@"下载1:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载2:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载3:%@",[NSThread currentThread]);
    }];

}

执行结果：按照任务添加顺序执行，所以是串行队列
技术分享

2.并发队列示例

- (void)blockQueue
{
    //  创建非主队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    //  设置最大并发数为6，一般子线程控制在6以内，太多线程会使设备压力过大
    queue.maxConcurrentOperationCount = 6;

    [queue addOperationWithBlock:^{
        NSLog(@"下载1:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载2:%@",[NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"下载3:%@",[NSThread currentThread]);
    }];

}

执行结果：程序并没有按照添加顺序完成任务，所以是并发执行

技术分享

#### 注意：
1. 一般子线程控制在6以内，太多线程会使设备压力过大
2. maxConcurrentOperationCount默认值为-1（在计算机中，-1一般指最大值）
3. 如果将maxConcurrentOperationCount设置为0，说明同一时间内执行0个任务，所以任务将不会执行。

技术分享

NSOperation暂停、恢复和取消功能

在NSOperation中，已经为我们提供了暂停、恢复和取消的功能，我们只需调用相应的方法即可。

1.暂停

    //  暂停
    [queue setSuspended:YES];

2.恢复

    //  取消
    [queue setSuspended:NO];

3.取消

    //  取消队列中所有操作,且取消后的任务不可恢复
    [queue cancelAllOperations];

注意：

1.队列中的的任务是有状态的，分别是 —— 等待；执行；完成三种状态，且暂停、恢复和取消操作并不能作用于当前正处于执行状态的任务，只能作用于等待状态的任务。
2.如果是自定义的NSOperation，会发现暂停、恢复操作对其无效，对于这种情况，可以用以下方式解决 —— 使用取消操作

- (void)main
{
    //  模拟耗时操作
    for (int i = 0; i< 200; i++) {
        NSLog(@"1当前线程：%@", [NSThread currentThread]);
    }
    //  判断当前状态，如果已经取消，直接返回
    if (self.cancelled) return;

    //  模拟耗时操作
    for (int i = 0; i< 200; i++) {
        NSLog(@"2当前线程：%@", [NSThread currentThread]);
    }
    //  判断当前状态，如果已经取消，直接返回
    if (self.cancelled) return;

    //  模拟耗时操作
    for (int i = 0; i< 200; i++) {
        NSLog(@"3当前线程：%@", [NSThread currentThread]);
    }
    //  判断当前状态，如果已经取消，直接返回
    if (self.cancelled) return;
}

解决问题思路：其实这是苹果官方文档中的建议 —— 因为，当我们调用cancelAllOperations:方法的时候，他内部的cancelled属性就会为真，每执行完一个耗时操作后都进行一次判断，如果发现已经取消，则退出执行。如果想更精确操控的话，也可以将判断操作放到耗时操作中，但是不建议这样做，因为这样性能极差。

NSOperation中的依赖操作

NSOperation提供了一套非常便捷好用的操作依赖方式，比起GCD，那种酸爽简直不敢相信

- (void)blockQueue
{
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载1:%@",[NSThread currentThread]);
    }];

    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载2:%@",[NSThread currentThread]);
    }];

    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载3:%@",[NSThread currentThread]);
    }];

    //  设置依赖关系
    //  op1依赖op2，只有当op2执行完毕后，才会执行op1
    [op1 addDependency:op2];
    //  op2依赖op3，只有当op3执行完毕后，才会执行op2
    [op2 addDependency:op3];

    //  获取主队列
    NSOperationQueue *queue = [NSOperationQueue mainQueue];

    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];

执行结果：先执行完op3，等op3执行完成后才执行op2，当op2执行完毕后，才执行op1

技术分享

注意

NSOperation提供的操作依赖功能特别强大，可以设置不同队列的依赖
但是不能循环依赖，比如op1依赖op2，op2又依赖op1，而且并不会报错，但会发生死锁，且有关任务都不执行。

NSOperation的监听

我们经常有这样的需要：在某些任务执行完成后，再执行指定的某些操作，那么NSOperation中的监听功能就派上用场了,使用非常简单

    NSOperation *op = [[NSOperation alloc] init];

    op.completionBlock = ^{
        NSLog(@"下载完成");
    };

    [op start];

NSOperation线程间通信

NSOperation线程间的通信类似于GCD，所以就不多叙述了，直接上代码

- (void)downloadPhoto
{
    //  获取非主队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    //  创建下载任务
    [queue addOperationWithBlock:^{

        //  图片地址
        NSURL *url = [NSURL URLWithString:@"http://cdn.duitang.com/uploads/item/201512/05/20151205092106_aksZU.jpeg"];
        //  下载图片
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        //  转换图片
        UIImage *image = [UIImage imageWithData:imageData];
        //  回到主线程刷新
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{

            NSLog(@"回%@线程刷新UI", [NSThread currentThread]);

            self.imageView.image = image;
        }];

    }];
}

执行结果：

技术分享

GCD和NSOperation区别

　　在开发中最常用的就是GCD和NSOperation来进行多线程开发，NSThread更多是在测试时辅助使用，pthread则很少看见，这里为大家简单整理一下他们之间的区别

GCD和NSOperation的对比
- GCD是纯C语言的API，而操作队列（NSOperation）则是Object-C的对象
- 在GCD中，任务用Block块来表示，而块是轻量级的数据结构，相反，操作队列（NSOperation）中的操作NSOperation是比较重量级的Object-C对象
那么在开发中如何选择呢？
- 一般如果任务之间有依赖关系或者需要监听任务执行的过程（KVO），首选NSOperation
- 单纯进行一些耗时操作则选用GCD，因为相比NSOperation,GCD效率更高，性能更好
NSOperation和NSOperationQueue好处
- NSOperation可以方便设置操作优先级（表示操作在队列中与其它操作之间的优先关系，级别越高越先执行）
- NSOperation可以通过KVO的方式对NSOperation对象进行监听控制（监听当前操作是处于完成，取消还是执行状态）
- NSOperation可以方便设置操作之间的依赖关系
- 通过自定义NSOperation子类可以实现操作复用

iOS 多线程浅述

标签：

原文地址：http://blog.csdn.net/yeshaojian/article/details/51213430

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

iOS 多线程 浅述

什么是进程？

什么是线程？

小拓展：

什么是多线程？

多线程优缺点：

多线程在iOS开发中的应用

线程的状态

注意：线程死亡后不能复生

线程安全：

IOS中多线程的实现方案

pthread简单使用

NSThread简单使用

这边介绍NSThread创建线程的4种方式：

线程间通信

GCD简单使用

什么是GCD

GCD优势

GCD的组合方式

注意同步函数和异步函数在执行顺序上面的差异

GCD的任务和队列

GCD的使用

GCD创建线程

结论：

结论：

结论

系统提供的4个全局并发队列

特殊的串行队列 —— 主队列（与主线程相关联的队列）

如果要解决以上的情况，那么可以将任务添加到子线程中，这样就不会出现死锁的情况，程序也就能够正常执行了

总结

注意

GCD线程间的通信

GCD延迟执行

一次性代码

栅栏函数

GCD迭代开发（遍历）

队列组

队列组函数内部操作简要流程

补充：同步\异步函数另一种创建方式

GCD一些需要注意的细节

NSOperation简单使用

NSOperation作用

NSOperation和NSOperationQueue实现多线程的具体步骤

NSOperation的子类

NSOperation封装操作

NSOperation中的队列

注意：addOperation:内部已经帮我们执行了开启任务方法，所有不需要另外实现。

NSBlockOperation与队列并用的简单写法

设置最大并发数

NSOperation暂停、恢复和取消功能

注意：

NSOperation中的依赖操作

注意

NSOperation的监听

NSOperation线程间通信

GCD和NSOperation区别

iOS 多线程浅述

`小拓展`：

`注意：线程死亡后不能复生`

`注意同步函数和异步函数在执行顺序上面的差异`

`结论`

`如果要解决以上的情况，那么可以将任务添加到子线程中，这样就不会出现死锁的情况，程序也就能够正常执行了`

`总结`

`注意`

`队列组函数内部操作简要流程`