Hadoop MapReduce优化和资源调度器

在及时篇稿子被,我以为你整一下 iOS
开发中几栽多线程方案,以及该下方法以及注意事项。当然也会吃起几乎种多线程的案例,在事实上利用被感受它们的区分。还有少数消验证的是,这篇稿子用见面用
SwiftObjective-c 两种植语言教学,双语幼儿园。OK,let’s begin!

Hadoop Shuffle过程

概述

立马首文章被,我非会见说基本上线程是呀、线程和经过的分别、多线程有啊用,当然我吗不见面说啊是串行、什么是互相等问题,这些我们理应还懂得的。

在 iOS 中实际目前来 4 套多线程方案,他们各自是:

  • Pthreads
  • NSThread
  • GCD
  • NSOperation & NSOperationQueue

用接下,我会一一讲解这些方案的使用方法和有些案例。在用这些情节的时刻,我吧会见有意无意说一些基本上线程周边产品。比如:
线程同步延时执行单例模式 等等。

1.Hadoop MapReduce Shuffle过程

Hadoop Shuffle过程

Map Shuffle过程图2

Pthreads

骨子里这个方案不用说的,只是用来充个数,为了给大家探听一下即好了。百度百科里是这么说之:

POSIX线程(POSIX
threads),简称Pthreads,是线程的POSIX标准。该标准定义了创办同操纵线程的一整套API。在类Unix操作系统(Unix、Linux、Mac
OS X等)中,都采用Pthreads作为操作系统的线程。

粗略地游说,这是一样效于许多操作系统及且通用的多线程API,所以移植性很强(然并卵),当然在
iOS 中为是足以的。不过这是基于 c语言
的框架,使用起来就酸爽!感受一下:

2.Shuffle进程要记录

  1. 每个Map Task把出口结果写及外存中的环形缓冲区。
  2. 当内存环形缓冲区写副的数据量达到自然阈值时,后台线程会拿
    数据溢写到磁盘。

    • 基于Partitioner,把数量写入到不同之partition
    • 于每个partition的数目开展排序
  3. 趁着Map Task的不停运行,磁盘上之溢出起文件进一步多
    • 拿这些溢起文件合并
    • 对此一个partition下的两样分片,使用由并排序,同一分区内数据有序
  4. Reduce Task通过网络远程拷贝MapTask的结果文件被的属于它们的分区数据

    • 联合有曾经拷贝过来的数据文件
    • 应用由并排序算法,对文件数量内容整理排序,将同样key的数分
      为同样组,不同key之间有序
    • 最后老成一个key对诺同组值的数据集,一个key对应之等同组数据会调用一潮reduce方法
  5. Combinery优化总结

Combiner优化

  1. Combiner调用之地方
    • MapTask的环形缓冲区向磁盘溢写文件前调用Combiner
    • Map阶段在联合本地多个公文写副一个挺文件前调用Combiner
  2. 使用Combiner的好处
    • 减去Map Task输出数据量,由于临时结果写副到当地磁盘,所以能够
      够减少磁盘IO
    • 削减Reduce-Map网络传输数据量,由于reduce需要远距离通过网络自
      Map拷贝数据,提高拷贝速度
  3. 运场景
    • 对结果可以增大的现象
    • SUM(YES) Average(NO)
  4. 安装方法(local reducer)
    • job.setCombinerClass(WordCountReducer.class)
OBJECTIVE-C

当首先步要包含头文件

#import <pthread.h>

然后创建线程,并施行任务

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    pthread_t thread;
    //创建一个线程并自动执行
    pthread_create(&thread, NULL, start, NULL);
}

void *start(void *data) {
    NSLog(@"%@", [NSThread currentThread]);

    return NULL;
}

打印输出:

2015-07-27 23:57:21.689 testThread[10616:2644653] <NSThread:
0x7fbb48d33690>{number = 2, name = (null)}

关押代码就会见发现他索要
c语言函数,这是比蛋疼的,更蛋疼的是您要手动处理线程的各个状态的易即管理生命周期,比如,这段代码虽然创立了一个线程,但连从未灭绝。

4.YARN 资源调度器

SWIFT

酷不满,在自家时之 swift1.2
中无法实施及时套方法,原因是者函数需要传入一个函数指针
CFunctionPointer<T> 类型,但是时 swift 无法将方换成此类型。听说
swift 2.0 引入一个新特征 @convention(c), 可以成功 Swift 方法换成为 c
语言指针的。在这边可以看出

那么,Pthreads 方案的多线程我虽介绍这么多,毕竟做 iOS
开发几乎不容许因此到。但是要是您感兴趣的话,或者说眷恋使团结实现均等模拟多线程方案,从底层开始定制,那么可以去抄一下息息相关材料。

1. YARN-FIFO Scheduler

用富有应用程序放入到一个阵中

  • 红旗入队里排在前的程序先获得资源

局限性

  • 资源利用率低,无法交叉运行作业
  • 不够利索,比如紧急的学业无法插队,耗时长作业拖慢耗时短作业

NSThread

当时套方案是通过苹果封装后的,并且完全面向对象的。所以若可一直操控线程对象,非常直观和便民。但是,它的生命周期还是待我们手动管理,所以这套方案吗是偶发用用,比如
[NSThread currentThread],它可博得当前线程类,你不怕可了解当前线程的各种性能,用于调试好好。下面来探视它的部分用法。

2. YARN-多队列分开调度器

怀有资源按照比例划分到不同之阵

每个阵可以实现独立的调度策略

优点

  • 按不同之资源用状态将资源划分到不同队列
  • 克吃再多的应用程序获得资源
  • 应用灵活,资源利用率高

调度器

  • CapacityScheduler调度器
  • FairScheduler调度器

CapacityScheduler

  • 鉴于Yahoo开源,共享集群调度器
  • 因行方式组织作业
  • 每个班中用FIFO调度策略
  • 每个阵分配一定比重资源
  • 不过限每个用户用资源量

    CapacityScheduler.png

**CapacityScheduler 配置方法**

于yarn-site.xml 设置使用CapacityScheduler调度器

<property>
    <name>yarn.resourcemanager.scheduler.class</name>
    <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
</property>

以Hadoop配置文件目录下/usr/local/hadoop/etc/hadoop创建capacity-scheduler.xml,添加信息如下:

<configuration>
    <property>
        <name>yarn.scheduler.capacity.root.queues</name>
        <value>default,data-bi</value>
    </property>
    <property>
        <name>yarn.scheduler.capacity.root.default.capacity</name> 
        <value>60</value>
    </property>
    <property>
        <name>yarn.scheduler.capacity.root.default.maximum-capacity</name>
        <value>80</value>
    </property>
    <property>
        <name>yarn.scheduler.capacity.root.bi.capacity</name>
        <value>40</vaule>
    </property>
</configuration>

配置说明

  • capacity-scheduler.xml参数说明
  • capacity:队列占用的集群资源容量百分比,所有班的容量 之同应低于100
  • maximum-capacity:由于有资源共享,因此一个队使用
    的资源量可能跨越该容量,而极度多用资源量可经该参数 限制
  • 安排好无需再启YARN,使用管理命令刷新调度安排 bin/yarn rmadmin
    -refreshQueues

FairScheduler

正义调度器的目的:

  • 容多用户共享集群资源。
  • 兴临时的即作业以及长时作业共享集群资源
  • 根据比例来管理集群资源,确保集群资源的有用利用’

FairScheduler配置方式
以Hadoop配置目录下/usr/local/hadoop/etc/hadoop yarn-site.xml
增加如下信:

<property>
        <name>yarn.resourcemanager.scheduler.class</name>
        <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler</value>
    </property>
    <property>
        <name>yarn.scheduler.fair.user-as-default-queue</name>
        <value>true</value>
    </property>
    <property>
        <name>yarn.scheduler.fair.allocation.file</name>
        <value>/usr/local/hadoop/etc/hadoop/fair-scheduler.xml</value>
    </property>
    <property>
        <name>yarn.scheduler.fair.preemption</name>
        <value>true</value>
    </property>

新建一个公调度安排文件fair-scheduler.xml ,信息如下:

<allocations>
    <queue name="data_bi">
        <minResources>8000 mb,4 vcores</minResources>
        <maxResources>10000 mb, 6 vcores</maxResources>
        <maxRunningApps>2</maxRunningApps>
        <weight>1.0</weight>
    </queue>
</allocations>

上述配置为 data_bi 用户称当正义调度的队名称。

yarn-site.xml参数说明

  • yarn.resourcemanager.scheduler.class配置yarn使用的调度器类型
  • yarn.scheduler.fair.allocation.file配置公平调度器自定义配置文件路径,该公文每隔10秒即会让加载一不良,这样就是可以以集群运行过程被改变队列的部署
  • yarn.scheduler.fair.user-as-default-queue当应用程序未指定队列名时,是否指定用户称当应用程序所当的行列名。如果设置为false或者不设置,所有
    未知队列的应用程序将受交给到default队列中,默认值为true
  • yarn.scheduler.fair.preemption如果一个班占用的资源量少于最小资源量限制,是否启用资源抢占,默认false。抢占机制得以要其他队的课业容器终止,从而使占用的资源让出,将资源分配为占资源量少于最小资源量限制的队

fair-scheduler.xml参数说明

  • queue name:配置队列名
  • minResources :分配受该队的最小资源量,设置格式为“X mb, Y
    vcores”,当调度策略属性schedulingPolicy的属于性值是fair时,其cores值会被忽略,仅据申请的内存大小来调度。
  • maxResources:分配为该队的极端酷资源量。设置格式为“X mb, Y
    vcores”,当调度策略属性schedulingPolicy的属性值是fair时,其cores值会被忽视,仅按申请之内存大小来调度。
  • maxRunningApps:最多而运行的应用程序数目。通过限制该多少,可防超量MapTask同时运行时生的中档输出结果撑爆磁盘。
  • weight:标记了资源池的权重,当资源池中来职责等,并且集众多被出空暇资源上,每个资源池可以根据权重获得不同比重的集群空闲资源,默认值是1

始建并启动

  • 预先创建线程类,再开行

    ###### OBJECTIVE-C

      // 创建
      NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:nil];
    
      // 启动
      [thread start];
    

    ###### SWIFT

      //创建
      let thread = NSThread(target: self, selector: "run:", object: nil)
    
      //启动
      thread.start()
    
  • 开创并机关启动

    ###### OBJECTIVE-C

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

    ###### SWIFT

      NSThread.detachNewThreadSelector("run:", toTarget: self, withObject: nil)
    
  • 运用 NSObject 的办法创建并自行启动

    ###### OBJECTIVE-C

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

    ###### SWIFT

    很遗憾 too! 苹果认为 performSelector: 不安全,所以当 Swift
    去丢了这方法。

    Note: The performSelector: method and related selector-invoking
    methods are not imported in Swift because they are inherently
    unsafe.

其他办法

除了创建启动外,NSThread
还以群艺术,下面我列举部分大规模的措施,当然我列举的连无完整,更多道大家好去类的概念里去押。

OBJECTIVE-C
//取消线程
- (void)cancel;

//启动线程
- (void)start;

//判断某个线程的状态的属性
@property (readonly, getter=isExecuting) BOOL executing;
@property (readonly, getter=isFinished) BOOL finished;
@property (readonly, getter=isCancelled) BOOL cancelled;

//设置和获取线程名字
-(void)setName:(NSString *)n;
-(NSString *)name;

//获取当前线程信息
+ (NSThread *)currentThread;

//获取主线程信息
+ (NSThread *)mainThread;

//使当前线程暂停一段时间,或者暂停到某个时刻
+ (void)sleepForTimeInterval:(NSTimeInterval)time;
+ (void)sleepUntilDate:(NSDate *)date;
SWIFT

Swift的方法名字以及OC的法子名都相同,我就非浪费空间列举出了。

实际上,NSThread
用起来吧充分简单的,因为其就那么几种方式。同时,我们为惟有以部分非常简单的观才见面因此
NSThread,
毕竟她还不够智能,不可知优雅地拍卖多线程中之另高档概念。所以接下要说的内容才是重点。

GCD

Grand Central Dispatch,听名字即横。它是苹果也多对的相互运算提出的缓解方案,所以会自行合理地动更多的CPU内核(比如双核、四审批),最关键的凡其见面自行管理线程的生命周期(创建线程、调度任务、销毁线程),完全不需要我们管理,我们仅仅待报干什么就实行。同时它利用的吧是
c语言,不过是因为采用了
Block(Swift里称闭包),使得用起来越便民,而且灵活。所以基本上大家都采取
GCD
这套方案,老少咸宜,实在是家旅行、杀人灭口,必备良药。不好意思,有接触着第二,咱们继续。

职责和排

GCD 中,加入了片只好重大的定义: 任务队列

  • 职责:即操作,你想要怎么,说白了便是一样段落代码,在 GCD 中不怕是一个
    Block,所以添加任务非常有利。任务产生少种实施方: 一同实施
    异步执行,他们中的分是 是否会创建新的线程

    一起施行只要是同步执行的任务,都会在当前线程执行,不会另开线程。

    异步执行只要是异步执行的任务,都会另开线程,在别的线程执行。

    更新
    此处说之并无规范,同步(sync)异步(async)
    的重大区别在会无会见卡住时线程,直到 Block
    中的职责履行了!
    如果是 同步(sync) 操作,它见面死时线程并伺机 Block
    中之职责履行完毕,然后当前线程才会连续朝生运作。
    如果是
    异步(async)操作,当前线程会一直向生实行,它不见面阻塞时线程。

  • 队列:用于存放任务。一共来三三两两种植队列, 阴差阳错行队列互相队列

    错行队列 中的职责会冲队列的概念 FIFO
    的实践,一个连通一个的先进先出的展开实施。

更新:放到串行队列的职责,GCD 会 FIFO(先进先出)
地取出来一个,执行一个,然后取下一个,这样一个一个底实施。

互相队列 中之天职 根据同步或异步有不同的执行方式。

更新:放到并行队列的职责,GCD 也会见
FIFO的拿走下,但不同的凡,它赢得下一个就算会放别的线程,然后再度拿走出来一个并且坐任何一个底线程。这样由得到的动作快捷,忽略不计,看起,所有的任务都是同实施的。不过用专注,GCD
会根据系统资源控制并行的数量,所以要是任务多,它并无会见为具有任务而施行。

尽管如此充分绕,但求看下表:

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

始建行

  • 主队列:这是一个特别之
    串行队列。什么是主队列,大家还明白吧,它用来刷新 UI,任何要刷新
    UI 的干活且要当主队列执行,所以一般耗时的任务还如放置别的线程执行。

      //OBJECTIVE-C
      dispatch_queue_t queue = ispatch_get_main_queue();
    
      //SWIFT
      let queue = ispatch_get_main_queue()
    
  • 友善创办的序列凡是自己创建的队列都是 `串行队列`。
    其中第一独参数是标识符,用于 DEBUG
    的上标识唯一的队,可以为空。大家可看xcode的文档查看参数意义。

更新:自己可创建 串行队列, 也得创造
并行队列。看下的代码(代码已经更新),它发生少个参数,第一单方面已说了,第二独才是最最重大之。
亚只参数用来表示创建的序列是串行的或者并行的,传入
DISPATCH_QUEUE_SERIALNULL 表示创建串行队列。传入
DISPATCH_QUEUE_CONCURRENT 表示创建并行队列。

  //OBJECTIVE-C
  //串行队列
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", NULL);
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_SERIAL);
  //并行队列
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_CONCURRENT);

  //SWIFT
  //串行队列
  let queue = dispatch_queue_create("tk.bourne.testQueue", nil);
  let queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_SERIAL)
  //并行队列
  let queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_CONCURRENT)
  • 大局并行队列这应该是唯一一个并行队列,
    只要是并行任务一般还进入到是班。这是系提供的一个涌出队列。

      //OBJECTIVE-C
      dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
      //SWIFT
      let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    

创办任务

  • 合任务: 不会另开线程 改:会阻塞时线程 (SYNC)

    ###### OBJECTIVE-C

      dispatch_sync(<#queue#>, ^{
          //code here
          NSLog(@"%@", [NSThread currentThread]);
      });
    

    ###### SWIFT

      dispatch_sync(<#queue#>, { () -> Void in
          //code here
          println(NSThread.currentThread())
      })
    
  • 异步任务:会另开线程 改:不见面死时线程 (ASYNC)

    ###### OBJECTIVE-C

      dispatch_async(<#queue#>, ^{
          //code here
          NSLog(@"%@", [NSThread currentThread]);
      });
    

    ###### SWIFT

      dispatch_async(<#queue#>, { () -> Void in
          //code here
          println(NSThread.currentThread())
      })
    

更新
为还好的掌握并同异步,和各种队列的运用,下面看少独示范:

示例一:
以下代码在主线程调用,结果是呀?

NSLog("之前 - %@", NSThread.currentThread())
dispatch_sync(dispatch_get_main_queue(), { () -> Void in 
        NSLog("sync - %@", NSThread.currentThread())
})
NSLog("之后 - %@", NSThread.currentThread())

答案:
无非会打印第一句子:之前 - <NSThread: 0x7fb3a9e16470>{number = 1, name = main}
,然后主线程就卡壳坏了,你可以在界面上加大一个按钮,你虽会见发现沾不了了。
解释:
一齐任务会阻塞时线程,然后拿 Block
中之职责放到指定的队列中施行,只有等交 Block
中之任务完成后才见面被眼前线程继续为生运作。
那这里的手续就是是:打印了第一句后,dispatch_sync
立即阻塞时之主线程,然后拿 Block 中的任务放到 main_queue 中,可是
main_queue
中的任务会叫拿走下放到主线程遭遇实践,但主线程这个时节曾经让死了,所以
Block 中的任务便非能够做到,它不到位,dispatch_sync
就会一直不通主线程,这虽是死锁现象。导致主线程一直卡死。

示例二:
以下代码会生出什么结果?

let queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL)

NSLog(“之前 – %@”, NSThread.currentThread())

dispatch_async(queue, { () -> Void in
    NSLog("sync之前 - %@", NSThread.currentThread())
    dispatch_sync(queue, { () -> Void in
         NSLog("sync - %@", NSThread.currentThread())
    })
    NSLog("sync之后 - %@", NSThread.currentThread())

})

NSLog(“之后 – %@”, NSThread.currentThread())

**答案:**
2015-07-30 02:06:51.058 test[33329:8793087] 之前 - <NSThread: 0x7fe32050dbb0>{number = 1, name = main}
2015-07-30 02:06:51.059 test[33329:8793356] sync之前 - <NSThread: 0x7fe32062e9f0>{number = 2, name = (null)}
2015-07-30 02:06:51.059 test[33329:8793087] 之后 - <NSThread: 0x7fe32050dbb0>{number = 1, name = main}
很明显 `sync - %@` 和 `sync之后 - %@` 没有被打印出来!这是为什么呢?我们再来分析一下:

>**分析:**
我们按执行顺序一步步来哦:
1. 使用 `DISPATCH_QUEUE_SERIAL` 这个参数,创建了一个 **串行队列**。
2. 打印出 `之前 - %@` 这句。
3. `dispatch_async` 异步执行,所以当前线程不会被阻塞,于是有了两条线程,一条当前线程继续往下打印出 `之后 - %@`这句, 另一台执行 Block 中的内容打印 `sync之前 - %@` 这句。因为这两条是并行的,所以打印的先后顺序无所谓。
4. 注意,高潮来了。现在的情况和上一个例子一样了。`dispatch_sync`同步执行,于是它所在的线程会被阻塞,一直等到 `sync` 里的任务执行完才会继续往下。于是 `sync` 就高兴的把自己 Block 中的任务放到 `queue` 中,可谁想 `queue` 是一个串行队列,一次执行一个任务,所以 `sync` 的 Block 必须等到前一个任务执行完毕,可万万没想到的是 `queue` 正在执行的任务就是被 `sync` 阻塞了的那个。于是又发生了死锁。所以 `sync` 所在的线程被卡死了。剩下的两句代码自然不会打印。 


### 队列组

队列组可以将很多队列添加到一个组里,这样做的好处是,当这个组里所有的任务都执行完了,队列组会通过一个方法通知我们。下面是使用方法,这是一个很实用的功能。

###### OBJECTIVE-C

``` objective-c
//1.创建队列组
dispatch_group_t group = dispatch_group_create();
//2.创建队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//3.多次使用队列组的方法执行任务, 只有异步方法
//3.1.执行3次循环
dispatch_group_async(group, queue, ^{
   for (NSInteger i = 0; i < 3; i++) {
       NSLog(@"group-01 - %@", [NSThread currentThread]);
   }
});

//3.2.主队列执行8次循环
dispatch_group_async(group, dispatch_get_main_queue(), ^{
   for (NSInteger i = 0; i < 8; i++) {
       NSLog(@"group-02 - %@", [NSThread currentThread]);
   }
});

//3.3.执行5次循环
dispatch_group_async(group, queue, ^{
   for (NSInteger i = 0; i < 5; i++) {
       NSLog(@"group-03 - %@", [NSThread currentThread]);
   }
});

//4.都完成后会自动通知
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   NSLog(@"完成 - %@", [NSThread currentThread]);
});
SWIFT
//1.创建队列组
let group = dispatch_group_create()
//2.创建队列
let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

//3.多次使用队列组的方法执行任务, 只有异步方法
//3.1.执行3次循环
dispatch_group_async(group, queue) { () -> Void in
    for _ in 0..<3 {
        NSLog("group-01 - %@", NSThread.currentThread())
    }
}

//3.2.主队列执行8次循环
dispatch_group_async(group, dispatch_get_main_queue()) { () -> Void in
    for _ in 0..<8 {
        NSLog("group-02 - %@", NSThread.currentThread())
    }
}

//3.3.执行5次循环
dispatch_group_async(group, queue) { () -> Void in
    for _ in 0..<5 {
        NSLog("group-03 - %@", NSThread.currentThread())
    }
}

//4.都完成后会自动通知
dispatch_group_notify(group, dispatch_get_main_queue()) { () -> Void in
    NSLog("完成 - %@", NSThread.currentThread())
}

打印结果

2015-07-28 03:40:34.277 test[12540:3319271] group-03 – <NSThread:
0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319271] group-03 – <NSThread:
0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 – <NSThread:
0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 – <NSThread:
0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319273] group-01 – <NSThread:
0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 – <NSThread:
0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 – <NSThread:
0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 – <NSThread:
0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 – <NSThread:
0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] 完成 – <NSThread:
0x7f977240ba60>{number = 1, name = main}


这些虽是 GCD 的基本功能,但是她的能力极为不止这些,等说话完 NSOperation
后,我们重新来看望它的组成部分其他方面用途。而且,只要您想象力够长,你得做有重新好的用法。

更新:关于GCD,还有少单需要说的:

  • func dispatch_barrier_async(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
    以此艺术要是若传入的 queue,当您传入的 queue 是通过
    DISPATCH_QUEUE_CONCURRENT 参数自己创立的 queue
    时,这个方法会阻塞这个 queue小心是死 queue
    ,而休是死时线程
    ),一直相当及此 queue
    中排除在其前面的天职都执行到位后才会开始施行好,自己履行完毕后,再晤取消阻塞,使之
    queue 中排除在它们背后的职责继续执行。
    若果你传入的是外的 queue, 那么其就是与 dispatch_async 一样了。

  • func dispatch_barrier_sync(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
    以此艺术的动以及直达一个同等,传入
    从定义之起队列(DISPATCH_QUEUE_CONCURRENT),它跟上一个方法同样的不通
    queue,不同之凡 这个法还会 卡住时线程
    若是你传入的是其它的 queue, 那么其就是与 dispatch_sync 一样了。

NSOperation和NSOperationQueue

NSOperation 是苹果公司本着 GCD
的包裹,完全面向对象,所以下起来重新好明。 大家可观看
NSOperation 和 NSOperationQueue 分别针对许 GCD 的 任务 和 队列
。操作步骤也不行好掌握:

  1. 就要执行之职责封装到一个 NSOperation 对象中。
  2. 以之任务添加到一个 NSOperationQueue 对象中。

下一场系统便会见活动在尽任务。至于共还是异步、串行还是并行请继续为下看:

累加任务

值得说明的凡,NSOperation 只是一个抽象类,所以未可知封装任务。但它们产生 2
个子类用于封装任务。分别是:NSInvocationOperation
NSBlockOperation 。创建一个 Operation 后,需要调用 start
方法来启动任务,它会
默认在脚下行同步实施。当然你为堪当半路取消一个任务,只待调用其
cancel 方法即可。

  • NSInvocationOperation : 需要传入一个办法名。

    ###### OBJECTIVE-C

      //1.创建NSInvocationOperation对象
      NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    
      //2.开始执行
      [operation start];
    

    ###### SWIFT

    在 Swift 构建的和谐社会里,是容不生 NSInvocationOperation
    这种无是项目安全的跳梁小丑的。苹果如是说。这边产生相关解释

  • NSBlockOperation

    ###### OBJECTIVE-C

      //1.创建NSBlockOperation对象
      NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
          NSLog(@"%@", [NSThread currentThread]);
      }];
    
      //2.开始任务
      [operation start];
    

    ###### SWIFT

      //1.创建NSBlockOperation对象
      let operation = NSBlockOperation { () -> Void in
          println(NSThread.currentThread())
      }
    
      //2.开始任务
      operation.start()
    

    前说过这样的天职,默认会在手上线程执行。但是 NSBlockOperation
    还有一个方式:addExecutionBlock: ,通过这艺术好让 Operation
    添加多独执行 Block。这样 Operation 中之职责 会晤连作执行,它会
    在主线程和任何的大多独线程 执行这些任务,注意下面的打印结果:

    ###### OBJECTIVE-C

          //1.创建NSBlockOperation对象
          NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
              NSLog(@"%@", [NSThread currentThread]);
          }];
    
          //添加多个Block
          for (NSInteger i = 0; i < 5; i++) {
              [operation addExecutionBlock:^{
                  NSLog(@"第%ld次:%@", i, [NSThread currentThread]);
              }];
          }
    
          //2.开始任务
          [operation start];
    

    ###### SWIFT

            //1.创建NSBlockOperation对象
            let operation = NSBlockOperation { () -> Void in
                NSLog("%@", NSThread.currentThread())
            }
    
            //2.添加多个Block
            for i in 0..<5 {
                operation.addExecutionBlock { () -> Void in
                    NSLog("第%ld次 - %@", i, NSThread.currentThread())
                }
            }
    
            //2.开始任务
            operation.start()
    

    ###### 打印输出

    2015-07-28 17:50:16.585 test[17527:4095467] 第2次 –
    <NSThread: 0x7ff5c9701910>{number = 1, name = main}

    2015-07-28 17:50:16.585 test[17527:4095666] 第1次 –
    <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

    2015-07-28 17:50:16.585 test[17527:4095665] <NSThread:
    0x7ff5c961b610>{number = 3, name = (null)}

    2015-07-28 17:50:16.585 test[17527:4095662] 第0次 –
    <NSThread: 0x7ff5c948d310>{number = 2, name = (null)}

    2015-07-28 17:50:16.586 test[17527:4095666] 第3次 –
    <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

    2015-07-28 17:50:16.586 test[17527:4095467] 第4次 –
    <NSThread: 0x7ff5c9701910>{number = 1, name = main}

    NOTEaddExecutionBlock 方法要在 start()
    方法之前实施,否则就是会报错:

    ‘*** -[NSBlockOperation addExecutionBlock:]: blocks cannot be
    added after the operation has started executing or finished’

    NOTE:大家可能发现了一个题目,为什么我于 Swift 里打印输出使用
    NSLog() 而不是 println() 呢?原因是运用 print() / println()
    输出的话,它见面简单地动用 流(stream) 的概念,学了 C++
    的且亮。它见面将需要输出的每个字符一个一个之输出到控制台。普通应用并不曾问题,可是当多线程同步输出的当儿问题便来了,由于过多
    println()
    同时打印,就会见促成控制台上的字符混乱的堆在联名,而NSLog()
    就无此题材。到底是啊体统的为?你得把上面 NSLog() 改为
    println() ,然后同试就明白。 双重多 NSLog() 与 println()
    的界别看这里

  • 自定义Operation

    除了上面的少种 Operation 以外,我们还好由定义 Operation。自定义
    Operation 需要继承 NSOperation 类,并促成其 main()
    方法,因为在调用 start() 方法的时节,内部会调用 main()
    方法好相关逻辑。所以要上述之星星只八九不离十无法满足你的私欲之上,你虽用打定义了。你想如果促成啊功效都得以写以其间。除此之外,你还索要贯彻
    cancel()
    在内的各种方式。所以是职能提供被高级玩家,我以这边就背着了,等自身得为此到经常于研究它,到早晚或会见又开创新。

创行

圈罢地方的内容就是了解,我们得以调用一个 NSOperation 对象的 start()
方法来启动这个职责,但是这样做他们默认是 手拉手施行 的。就算是
addExecutionBlock 方法,也会在 当下线程和另外线程
中实行,也就是说要会占当前线程。这是快要用到行列 NSOperationQueue
了。而且,按类别来说的言辞一共来个别栽档次:主队列、其他队。一旦加上到队,会活动调用任务之
start() 方法

  • 主队列

    仔细的同学就会见意识,每套多线程方案都见面时有发生一个主线程(当然啦,说之是iOS中,像
    pthread 这种多系统的方案并没,因为 UI线程
    理论需要每种操作系统自己定制)。这是一个特种的线程,必须串行。所以添加到主队列的任务还见面一个接一个地解在帮于主线程处理。

    //OBJECTIVE-C
    NSOperationQueue *queue = [NSOperationQueue mainQueue];
    
    //SWIFT
    let queue = NSOperationQueue.mainQueue()
    

  • 外队

    因主队列于独特,所以会见独自生一个近乎方式来赢得主队列。那么通过初始化产生的排就是别队了,因为只有马上片种植阵,除了主队列,其他队就非需名字了。

    专注:其他队的职责会在其他线程并行执行。

    ###### OBJECTIVE-C

    //1.创建一个其他队列    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    //2.创建NSBlockOperation对象
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    
    //3.添加多个Block
    for (NSInteger i = 0; i < 5; i++) {
        [operation addExecutionBlock:^{
            NSLog(@"第%ld次:%@", i, [NSThread currentThread]);
        }];
    }
    
    //4.队列添加任务
    [queue addOperation:operation];
    

    ###### SWIFT

    //1.创建其他队列
    let queue = NSOperationQueue()
    
    //2.创建NSBlockOperation对象
    let operation = NSBlockOperation { () -> Void in
        NSLog("%@", NSThread.currentThread())
    }
    
    //3.添加多个Block
    for i in 0..<5 {
        operation.addExecutionBlock { () -> Void in
            NSLog("第%ld次 - %@", i, NSThread.currentThread())
        }
    }
    
    //4.队列添加任务
    queue.addOperation(operation)
    

    ###### 打印输出

    2015-07-28 20:26:28.463 test[18622:4443534] <NSThread:
    0x7fd022c3ac10>{number = 5, name = (null)}

    2015-07-28 20:26:28.463 test[18622:4443536] 第2次 –
    <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

    2015-07-28 20:26:28.463 test[18622:4443535] 第0次 –
    <NSThread: 0x7fd022f237f0>{number = 4, name = (null)}

    2015-07-28 20:26:28.463 test[18622:4443533] 第1次 –
    <NSThread: 0x7fd022d372b0>{number = 3, name = (null)}

    2015-07-28 20:26:28.463 test[18622:4443534] 第3次 –
    <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

    2015-07-28 20:26:28.463 test[18622:4443536] 第4次 –
    <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

OK, 这时应问了,大家以 NSOperationQueueGCD的队列
相比较就是会意识,这里没有串行队列,那如若本身想使10独任务在任何线程串行的履怎么收拾?

即就是是苹果封装的妙处,你不要管串行、并行、同步、异步这些名词。NSOperationQueue
有一个参数 maxConcurrentOperationCount
最可怜并发数,用来装极端多足吃多少只任务而履行。当您将她装也 1
的下,他莫就是串行了嘛!

NSOperationQueue
还有一个增长任务之法子,- (void)addOperationWithBlock:(void (^)(void))block;
,这是休是跟 GCD 差不多?这样虽可增长一个职责及行列中了,十分福利。

NSOperation 有一个深实用的机能,那便是添加依赖。比如有 3 独任务:A:
从服务器上下载一摆设图纸,B:给当下张图加个水印,C:把图纸返回给服务器。这时便可为此到因了:

OBJECTIVE-C
//1.任务一:下载图片
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"下载图片 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//2.任务二:打水印
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"打水印   - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//3.任务三:上传图片
NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"上传图片 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//4.设置依赖
[operation2 addDependency:operation1];      //任务二依赖任务一
[operation3 addDependency:operation2];      //任务三依赖任务二

//5.创建队列并加入任务
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];
SWIFT
//1.任务一:下载图片
let operation1 = NSBlockOperation { () -> Void in
    NSLog("下载图片 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//2.任务二:打水印
let operation2 = NSBlockOperation { () -> Void in
    NSLog("打水印   - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//3.任务三:上传图片
let operation3 = NSBlockOperation { () -> Void in
    NSLog("上传图片 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//4.设置依赖
operation2.addDependency(operation1)    //任务二依赖任务一
operation3.addDependency(operation2)    //任务三依赖任务二

//5.创建队列并加入任务
let queue = NSOperationQueue()
queue.addOperations([operation3, operation2, operation1], waitUntilFinished: false)
打印结果

2015-07-28 21:24:28.622 test[19392:4637517] 下充斥图片 – <NSThread:
0x7fc10ad4d970>{number = 2, name = (null)}

2015-07-28 21:24:29.622 test[19392:4637515] 打水印 – <NSThread:
0x7fc10af20ef0>{number = 3, name = (null)}

2015-07-28 21:24:30.627 test[19392:4637515] 上传图片 – <NSThread:
0x7fc10af20ef0>{number = 3, name = (null)}

  • 小心:不克上加相互依赖,会死锁,比如 A因B,B依赖A。
  • 足使用 removeDependency 来消除因关系。
  • 好以不同之行列中因,反正就是是此仗是添加到任务身上的,和行没关系。

另外办法

上述就是是局部着重方式, 下面还有一部分常用方法要大家只顾:

  • NSOperation

    BOOL executing; //判断任务是否在行

    BOOL finished; //判断任务是否好

    void (^completionBlock)(void); //用来安完后用实施的操作

    – (void)cancel; //取消任务

    – (void)waitUntilFinished; //阻塞当前线程直到这任务尽了

  • NSOperationQueue

    NSUInteger operationCount; //获取队列的天职数

    – (void)cancelAllOperations; //取消队列中兼有的职责

    – (void)waitUntilAllOperationsAreFinished;
    //阻塞当前线程直到这个行列中之具备任务尽了

    [queue setSuspended:YES]; // 暂停queue

    [queue setSuspended:NO]; // 继续queue

哼哪,到此地基本上就是说了了。当然,我道的并无完全,可能发生部分知识我连没讲到,但当常用方法,这些早已足够了。不过我于此间只是报您了片艺术的法力,只是怎么管她们为此到当的地方,就需要多实践了。下面我会说有的有关多线程的案例,是大家更什么地问询。

其他用法

于就部分,我会说一些以及多线程知识相关的案例,可能有头生简单,大家早安还亮之,不过坐马上首文章称的是多线程嘛,所以当尽量的一揽子嘛。还有即使是,我会尽量的运用多种办法实现,让大家看看中的分。

线程同步

所谓线程同步就是为着预防多独线程抢夺和一个资源造成的数码安全问题,所采取的如出一辙栽方法。当然也产生为数不少兑现方式,请为下看:

  • 互斥锁
    :给需要共同的代码块加一个互斥锁,就可以确保每次仅生一个线程访问这个替码块。

    ###### OBJECTIVE-C

    @synchronized(self) {
      //需要执行的代码块
    }
    

    ###### SWIFT

    objc_sync_enter(self)
    //需要执行的代码块
    objc_sync_exit(self)
    
  • 联合执行
    :我们可动用多线程的知识,把多个线程都使尽此段代码添加到和一个串行队列,这样即使兑现了线程同步的概念。当然这里可以下
    GCDNSOperation 两栽方案,我还写出来。

    ###### OBJECTIVE-C

//GCD
//需要一个全局变量queue,要让所有线程的这个操作都加到一个queue中
dispatch_sync(queue, ^{
    NSInteger ticket = lastTicket;
    [NSThread sleepForTimeInterval:0.1];
    NSLog(@"%ld - %@",ticket, [NSThread currentThread]);
    ticket -= 1;
    lastTicket = ticket;
});


//NSOperation & NSOperationQueue
//重点:1. 全局的 NSOperationQueue, 所有的操作添加到同一个queue中
//       2. 设置 queue 的 maxConcurrentOperationCount 为 1
//       3. 如果后续操作需要Block中的结果,就需要调用每个操作的waitUntilFinished,阻塞当前线程,一直等到当前操作完成,才允许执行后面的。waitUntilFinished 要在添加到队列之后!

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    NSInteger ticket = lastTicket;
    [NSThread sleepForTimeInterval:1];
    NSLog(@"%ld - %@",ticket, [NSThread currentThread]);
    ticket -= 1;
    lastTicket = ticket;
}];

[queue addOperation:operation];

[operation waitUntilFinished];

//后续要做的事
SWIFT

此地的 swift 代码,我不怕未写了,因为各个句都如出一辙,只是语法不同而已,照在 OC
的代码就会写起 Swift
的。这篇稿子都老长老长了,我就是不浪费篇幅了,又不是高中写作文。

延执行

所谓延迟执行就是延时一段时间再实践某段代码。下面说有些常用方法。

  • perform

    ###### OBJECTIVE-C

    // 3秒后自动调用self的run:方法,并且传递参数:@"abc"
    [self performSelector:@selector(run:) withObject:@"abc" afterDelay:3];
    

    ###### SWIFT

    之前就已经说过,Swift 里去掉了这个方法。
    
  • GCD

    足应用 GCD 中之 dispatch_after 方法,OC 和 Swift
    都得采用,这里仅仅写 OC 的,Swift 的凡同一的。

    ###### OBJECTIVE-C

    // 创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 设置延时,单位秒
    double delay = 3; 
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), queue, ^{
      // 3秒后需要执行的任务
    });
    
  • NSTimer

    NSTimer
    是iOS中之一个计时器类,除了延迟执行还有为数不少所以法,不过此直说延迟执行之用法。同样只有写
    OC 版的,Swift 也是平之。

    ###### OBJECTIVE-C

    [NSTimer scheduledTimerWithTimeInterval:3.0 target:self selector:@selector(run:) userInfo:@"abc" repeats:NO];
    

单例模式

至于什么是单例模式,我也未多说,我只是说说一般怎么落实。在 Objective-C
中,实现单例的章程已颇实际了,虽然有别的方式,但是一般还是因此一个标准的道了,下面来瞧。

OBJECTIVE-C
@interface Tool : NSObject <NSCopying>

+ (instancetype)sharedTool;

@end

@implementation Tool

static id _instance;

+ (instancetype)sharedTool {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[Tool alloc] init];
    });

    return _instance;
}

@end

此处用用单例模式,是为其中以了 GCD 的 dispatch_once
方法。下面看 Swift 中的单例模式,在Swift中单例模式非常简单!想了解怎么由
OC
那么复杂的法子成为下面的写法的,请看这里

SWIFT
class Tool: NSObject {
    static let sharedTool = Tool()

    // 私有化构造方法,阻止其他对象使用这个类的默认的'()'构造方法
    private override init() {}
}

起其它线程回到主线程的主意

咱还知道在其余线程操作就后须顶主线程更新UI。所以,介绍了所有的多线程方案后,我们来看望有怎样措施好返回主线程。

  • NSThread

    //Objective-C
    [self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];
    
    //Swift
    //swift 取消了 performSelector 方法。
    
  • GCD

    //Objective-C
    dispatch_async(dispatch_get_main_queue(), ^{
    
    });
    
    //Swift
    dispatch_async(dispatch_get_main_queue(), { () -> Void in
    
    })
    
  • NSOperationQueue

    //Objective-C
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
    
    }];
    
    //Swift
    NSOperationQueue.mainQueue().addOperationWithBlock { () -> Void in
    
    }
    

总结

吓之吧,总算写了了,纯手敲6k多配,感动万分我了。花了点儿龙,时间跨度有硌异常,所以可能有点地方及段子未连贯下段或者部分地方不完整,如果您看在比较吃力或者出什么地方时有发生题目,都得以评论区告诉我,我会立马修改的。当然啦,多线程的东西呢持续这些,题目为不怕只是是独问题,不要当真。想如果了解再多之事物,还得自己失去网上开息息相关材料。多看官方文档。实在是造不下了,大家好好看~。对了,看自己写的这样努力,不从赏的讲话得点单爱好呢是最为好之。

更新:第一不行放出去的时刻,有好多地方来左,很谢谢有心上人提出来了。如果您见到出荒唐的地方,一定记得凭出来,这样针对性大家都出拉。还有某些对初学者的话,遇到不晓的道,最好之道尽管是查官方文档,那里是最好纯正之,就算出几个单词不认识,查一下即便吓了,不会见潜移默化对整的接头。
自己见状有网站转载了自我之章,但转载的可能有问题,而自不得不以简书上创新,所以要是要是拘留
完版本
还是顶简书来拘禁吧:此处是地点。

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注