有关iOS多线程,你看我就算足够了

开创行

  • 主队列:这是一个独特的
    串行队列。什么是主队列,大家都知情吧,它用来刷新 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)
    

青草开满鲜花

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];

性之诞生不远

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() {}
}

面朝大海,春暖花开,劈柴喂马,大概说的就是这些画面把

创任务

  • 一齐任务: 不会另开线程 改:会卡住时线程 (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]);
});

诚要为此好的步子丈量海子笔下以梦也马之西北偏西了,海子……

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语言函数,这是于蛋疼的,更蛋疼的是你得手动处理线程的依次状态的转移即管理生命周期,比如,这段代码虽然创立了一个线程,但并没有灭绝。

走过草原,跨了一望无垠,绕了戈壁,对望雪峰,偶遭遇湖泊,第一不良正式的跟那些地理书上撞了。

其它艺术

上述就是有的首要方法, 下面还有有常用方法要大家只顾:

  • 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

吓哪,到此地基本上就是摆了了。当然,我道的并无完,可能来一对学问我连没讲到,但当常用方法,这些已够了。不过自己当这里只是告诉您了一部分道的效应,只是怎么管他们据此到适当的地方,就需要多多实践了。下面我会说有关于多线程的案例,是豪门尤为什么地打听。

一头于西

开创行

扣押了点的情就是理解,我们得以调用一个 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
//取消线程
- (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;

手捧一羁绊梦想放飞

线程同步

所谓线程同步就是为以防多个线程抢夺和一个资源造成的数量安全问题,所下的等同种植艺术。当然为发生很多贯彻方式,请于生看:

  • 互斥锁
    :给要一起的代码块加一个互斥锁,就可管每次只有发生一个线程访问这个替码块。

    ###### 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的法名都平等,我哪怕未浪费空间列举出了。

实际,NSThread
用起来呢老简单的,因为它就是那几种植办法。同时,我们吧只有当一部分非常简单的情景才会就此
NSThread,
毕竟它还不够智能,不能够优雅地处理多线程中之任何高级概念。所以接下去要说之始末才是第一。

而自身展示凄凄迷人

于另外线程回到主线程的道

我们且亮在其他线程操作完后须顶主线程更新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
    
    }
    

蓝色的公主青海湖

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)

本人之孤寂如天堂的马儿

职责以及行

GCD 中,加入了点滴单可怜重要之概念: 任务队列

  • 任务:即操作,你想如果干什么,说白了即是千篇一律段代码,在 GCD 中便是一个
    Block,所以添加任务异常便民。任务来些许栽实施办法: 手拉手执行
    异步执行,他们中间的分别是 是否会创建新的线程

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

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

    更新
    此间说的连无规范,同步(sync)异步(async)
    的主要分在会不见面死时线程,直到 Block
    中之天职执行完毕!
    如果是 同步(sync) 操作,它会堵塞时线程并等 Block
    中的任务尽了,然后当前线程才见面继续向下运行。
    如果是
    异步(async)操作,当前线程会直接通往下实施,它不会见卡住时线程。

  • 队:用于存放任务。一共有个别栽队列, 出错行队列交互队列

    错行队列 中的任务会因队列的概念 FIFO
    的执行,一个连缀一个之先进先出的拓展实施。

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

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

更新:放到并行队列的任务,GCD 也会见
FIFO的博下,但不同的凡,它抱下一个虽会安放别的线程,然后再取出来一个而置任何一个之线程。这样由获得的动作敏捷,忽略不计,看起,所有的职责都是一块实施的。不过要注意,GCD
会根据系统资源控制并行的数,所以如果任务多,它并无会见为拥有任务而推行。

虽很绕,但求圈下表:

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

敦煌莫高窟

Pthreads

事实上是方案不用说之,只是以来充个数,为了让大家了解一下即便吓了。百度百科里是如此说的:

POSIX线程(POSIX
threads),简称Pthreads,是线程的POSIX标准。该专业定义了创造与操纵线程的身API。在类Unix操作系统(Unix、Linux、Mac
OS X等)中,都使Pthreads作为操作系统的线程。

简言之地游说,这是同一效仿于无数操作系统及还通用的多线程API,所以移植性很强(然并卵),当然在
iOS 中为是可的。不过当下是根据 c语言
的框架,使用起来就酸爽!感受一下:

蓝色之空,伸出云朵,高处,语言的石取下来,落于史的遗址上,先形成塔,后形成寺。塔尔寺,我们沿途的第一单藏传佛教圣地。在山梁,停下来的时光,望在对面山上博洒洒的寺庙,我同外说了同一声,hi。

SWIFT

这里的 swift 代码,我哪怕未写了,因为各级句都无异,只是语法不同而已,照在 OC
的代码就会写有 Swift
的。这首稿子都老长老长了,我虽未浪费篇幅了,又非是高级中学写作文。

塔尔寺

NSThread

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

大打动,而且这卖感动,类似于要失去变现一个暨和气于小定了娃娃亲的男方一样的动。好像我们大致了好久好久,一直为各种琐屑耽搁了,现在我们放弃了各种乱,专心致志的前往约了。

外方法

除此之外创建启动外,NSThread
还为博方,下面我列举部分广的主意,当然我列举的并无完全,更多计大家可以去类的定义里去押。

本身见你从阳光被意外来

于即时篇文章被,我以为你整一下 iOS
开发中几栽多线程方案,以及该行使方式以及注意事项。当然也会为闹几乎种多线程的案例,在事实上用被感受它们的区分。还有少数索要说明的是,这篇稿子用会晤使用
SwiftObjective-c 两种植语言教学,双语幼儿园。OK,let’s begin!

 ——王维

NSOperation和NSOperationQueue

NSOperation 是苹果公司针对 GCD
的包,完全面向对象,所以利用起来再次好明。 大家可看到
NSOperation 和 NSOperationQueue 分别针对许 GCD 的 任务 和 队列
。操作步骤也非常好明:

  1. 将要执行之任务封装到一个 NSOperation 对象中。
  2. 拿这个任务添加到一个 NSOperationQueue 对象中。

然后系统就是见面自动在实践任务。至于共还是异步、串行还是并行请继续朝着生看:

自己孤单的十指化为天及洁白的鸟

推执行

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

  • 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];
    

湖畔一样包扎捆蜂箱

SWIFT

十分遗憾,在自己当下的 swift1.2
中无法推行就套方法,原因是是函数需要传入一个函数指针
CFunctionPointer<T> 类型,但是当前 swift 无法拿计易成为此类型。听说
swift 2.0 引入一个初特征 @convention(c), 可以成功 Swift 方法易成 c
语言指针的。当此地可以观看

那么,Pthreads 方案的多线程我虽介绍这么多,毕竟做 iOS
开发几乎无可能就此到。但是倘若你感兴趣的话,或者说想要协调实现平等模仿多线程方案,从脚开始定制,那么可错过抄一下连锁资料。

盐湖

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 一样了。

 

总结

好的吧,总算写了了,纯手敲6k多配,感动好我了。花了少于天,时间跨度有硌非常,所以可能有点地方及段子非联网下段或者有些地方不整,如果你看在比较困难或者出啊地方产生题目,都好在评论区告诉我,我会立马修改的。当然啦,多线程的事物呢不断这些,题目也即单纯是单问题,不要当真。想如果打听又多之事物,还得自己失去网上开息息相关资料。多看看官方文档。实在是胡编不下去了,大家好好看~。对了,看我勾勒的如此努力,不从赏的说话得点单爱呢是绝好之。

更新:第一次于放出去的时刻,有成百上千地方发不当,很谢谢有意中人提出来了。如果你看到有错的地方,一定记得凭出来,这样对大家还发帮带。还有少数对初学者的话,遇到不掌握的不二法门,最好之方式就是翻开官方文档,那里是最可靠的,就算出几个单词不识,查一下即好了,不会见潜移默化对整体的敞亮。
自视出网站转载了我的文章,但转载的或是在问题,而自只能当简书上更新,所以要要看
整版本
还是到简书来拘禁吧:此是地点。

给其竟然上蓝天

丰富任务

值得说明的凡,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()
    在内的各种措施。所以这个功能提供于高级玩家,我当此处虽不说了,等自用因此到经常在研究它,到时刻或会见还开创新。

鸣沙山—月牙泉

概述

立即首文章被,我莫会见说基本上线程是呀、线程和过程的区分、多线程有啊用,当然我啊未见面说啊是串行、什么是互相等问题,这些我们相应还清楚的。

于 iOS 中实际上目前产生 4 套多线程方案,他们各自是:

  • Pthreads
  • NSThread
  • GCD
  • NSOperation & NSOperationQueue

之所以接下,我会一一讲解这些方案的使用办法和片案例。在用这些情节之上,我哉会见顺便说有大多线程周边产品。比如:
线程同步延时执行单例模式 等等。

爱情不远—-马鼻子下

GCD

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

单纯性、倒影、蓝白交织如同一庙会梦境

单例模式

关于什么是单例模式,我为非多说,我特说说一般怎么落实。在 Objective-C
中,实现单例的章程已颇现实了,虽然有别的方法,但是一般都是故一个规范的道了,下面来看望。

感觉到站于史里,诗歌中,想方几百年前,几千年前,诗人站于自家立的这个地方,写下就篇诗歌,他于思念什么吧

创建并启动

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

    ###### 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.

青海湖

其它用法

以马上有的,我会说有与多线程知识相关的案例,可能来几生简短,大家早安都知之,不过盖当时篇文章说的凡多线程嘛,所以应当尽可能的宏观嘛。还有即使是,我会尽量的以多种措施实现,让大家省里面的别。

是遗址

打印结果

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 来排遣因关系。
  • 足当不同之班中因,反正就是是是依靠是丰富到任务身上的,和排没关系。

 ——王之涣

茶卡盐湖名“天空之境”

七月休多

我们相约去草原吧

羌笛何须怨杨柳,春风不度玉门关。

不了解,是自己矫情,还是大西北立三独字我便真正豪气的等同倒下糊涂。从决定出发的那一刻即便神经质的以为温馨的丰采都有了变更,不由得,讲话豪爽,走路大步,笑起来憨厚,雄赳赳气昂昂,好像只有如此我才发资格踏上同向西。

素净、洁白、淡雅、高远

 我们去之时天气不好,并没有见到美丽。

溶解在白云的身体里

雅丹地貌

本身只有想到实在壮观

黄河多及白云间,一切开孤城万仞山。

自然界真的是极其得意的调色盘。流光溢彩,用当此太合适,然后在这里游玩了人生第一次等无人机,超级酷。

上是湖水的相同片,湖是上之增补

 ——海子

行程

湖含盐

魔鬼城,据说走进去便倒不出了

在此间,第一糟相了磕长头。这是藏传佛教信徒最为真挚之弥撒方式,我当挥洒里展现了累累森全副,我直接在惦记,我委看底时节,内心会是哪些的激荡。后来当大昭寺之门口,在朋友之鞭策下,我标标准按照的冲击了一个长头。没有许愿。

花海里啊,是来一致句情话的,爱尔一万年。据说门源的菜花是全国最充分。

 别人画面里之盐湖,这有限摆凡人家的为

斯张骞很出色!

​嗨,旁友,什么都生成说,快关注☝☝☝☝

劝君又老一杯子酒,西出阳关无故人!

荒漠的日落,大漠孤烟直,长河落日圆,一不小心又丢进了诗中。

当时点儿单剪影是本人杀满意的有数摆设相片。拍摄的通通为路人。在车子飞奔的下,疯狂的针对性正在天涯的她们猛拍。在车上看片的时候,很怀念让司机小白掉头回去,把当下片摆相片送给他们,但是于途中,很多姻缘就是是我们不认,却对而默契的笑笑了。于是,就如此把。

终极之日光燃烧后底灰烬

张掖丹霞地质公园

举凡塔是寺

故青海湖泊匪远

于言语的石头上颠簸

莫高窟管理非常专业,志愿服务做的极其知心的一个景。作为历史及博代的结晶,凝聚了成千上万时的文化,盛唐的更是华美。不得不惊叹,古代底手工业者,真是鬼斧神工,巧夺听人,天马行空,独具匠心。美得千篇一律塌糊涂。因为不能拍照,所以的确没拍。

——卢林

大西北姑娘,她是发出投机的风度的。如果说都大凡满族的格格,上海凡是民国的旗袍小姐,绍兴、苏州凡邻居的微家碧玉,那么西北就是横的野蛮女友,你免敢惹,但是你待罢不能够。

青海湖达成

菜花海

嘉峪关—阳关—玉门关

 ——诺布朗杰

常青真的很好的,比如,我们,哈哈哈。我们四点差不多好,然后看日出。

发表评论

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

网站地图xml地图