4.1/4.2 多线程进阶篇<上>（Pthread & NSThread）

本文并非最终版本，如有更新或更正会第一时间置顶，联系方式详见文末

如果觉得本文内容过长，请前往本人 “简书”

本文源码 Demo 详见 Github
https://github.com/shorfng/iOS-4.0-multithreading.git

 

因为Pthread很少用到，所以对于Pthread的知识没有抠那么细致，所以将Pthread和 NSThread放在了一起。

 

4.1 Pthread

---

4.1-1.0 创建线程 - pthread_create

/*
<#pthread_t *restrict#>  线程的id,指向线程标识符的指针，C 语言中类型的结尾通常 _t/Ref，而且不需要使用 *
<#const pthread_attr_t *restrict#> 用来设置线程的属性 (一般为 NULL)
<#void *(*)(void *)#>  新建立的线程执行代码的函数,线程开启后需要调用的函数或方法 (指向函数的指针)
<#void *restrict#>     运行函数的参数,线程的限制 (一般为 NULL)
*/

返回值：
 - 若线程创建成功，则返回0
 - 若线程创建失败，则返回出错编号

pthread_create(
          <#pthread_t *restrict#>,   // pthread_t :线程标识符.
          <#const pthread_attr_t *restrict#>,
          <#void *(*)(void *)#>,
          <#void *restrict#>
);

4.1-1.1 __bridge 桥接

__bridge 桥接：

1、在c语言和OC之间,对数据类型进行转成换

2、通过桥接告诉c语言的函数，name就由C语言去管了

桥接的目的 : 

就是为了告诉编译器如何管理内存，为OC添加自动内存管理操作

 

小结 ：

• 在 C 语言中，没有对象的概念，对象是以结构体的方式来实现的
• 通常，在 C 语言框架中，对象类型以 _t/Ref 结尾，而且声明时不需要使用 *
• C 语言中的 void * 和 OC 中的 id 是等价的
• 在混合开发时，如果在 C 和 OC 之间传递数据，需要使用 __bridge 进行桥接，
• 桥接的添加可以借助 Xcode 的辅助功能添加

 

number = 1: 表示 主线程

number != 1: 表示 子线程

 

C语言中 void * == OC中的id

C语言的数据类型,一般以  Ref / _t

• OC框架 Foundation

•   C语言 Core Foundation

 

 4.1-1.2【代码】Pthread

首先导入头文件

#import <pthread.h>

代码创建：

// 创建线程，并且在线程中执行 demo 函数
- (void)pthreadDemo {

  pthread_t threadId = NULL;
  NSString *str = @"Hello Pthread";

  int result = pthread_create(&threadId, NULL, demo, (__bridge void *)(str));

  if (result == 0) {
    NSLog(@"创建线程 OK");
  } else {
    NSLog(@"创建线程失败 %d", result);
  }
}

// 后台线程调用函数
void *demo(void *params) {
  NSString *str = (__bridge NSString *)(params);

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

  return NULL;
}

4.2  NSThread

---

4.2-1.0 创建线程

• 第一种:通过NSThread的对象方法 （alloc / init - start）
• 第二种:通过NSThread的类方法    （detachNewThreadSelector）
• 第三种:通过NSObject的方法

 4.2-1.1 创建线程1 - 对象方法alloc/init

一个NSThread对象就代表一条线程

创建方式1 : 通过NSThread的对象方法 (先创建初始化线程alloc/init , 再 start 开启线程)   ——调试方便

NSThread *thread = [[NSThread alloc]initWithTarget:<#(nonnull id)#>
                                          selector:<#(nonnull SEL)#>
                                            object:<#(nullable id)#> ];

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  [self threadDemo1];
}

#pragma mark - 对象方法alloc/init
/*
 - 在 OC 中，任何一个方法的代码都是从上向下顺序执行的
 - 同一个方法内的代码，都是在相同线程执行的(block除外)
 */
- (void)threadDemo1 {
  NSLog(@"before %@", [NSThread currentThread]);

  // 线程一启动，就会在线程thread中执行self的run方法
  NSThread *thread = [[NSThread alloc] initWithTarget:self
                                             selector:@selector(longOperation:)
                                               object:@"THREAD"];

  //开启线程,通过start方法,就会将我们创建出来的当前线程加入到`可调度线程池`,供CPU调度
  //[thread start];执行后，会在另外一个线程执行 longOperation: 方法
  [thread start];

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

- (void)longOperation:(id)obj {
  NSLog(@"%@ - %@", [NSThread currentThread], obj);
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

打印结果：

2016-03-17 18:19:41.878 创建线程1 - 对象方法[2543:387435] before <NSThread: 0x7ffd28c00ca0>{number = 1, name = main}
2016-03-17 18:19:41.880 创建线程1 - 对象方法[2543:387711] <NSThread: 0x7ffd28d77be0>{number = 2, name = (null)} - THREAD
2016-03-17 18:19:41.880 创建线程1 - 对象方法[2543:387435] after <NSThread: 0x7ffd28c00ca0>{number = 1, name = main}

　　

4.2-1.1.1 Target

NSThread 的实例化方法中的 target 指的是开启线程后，在线程中执行 哪一个对象 的 @selector 方法

NSThread *thread = [[NSThread alloc] initWithTarget:self.person
                                           selector:@selector(longOperation:)
                                             object:@"THREAD"];

[thread start];

• 通过指定不同的 target 会在后台线程执行该对象的 @selector 方法
• 不要看见 target 就写 self

4.2-1.2 创建线程2 - 类方法

创建方式2 : 通过NSThread的类方法 (创建线程后直接自动启动线程)

[NSThread detachNewThreadSelector:<#(nonnull SEL)#>
                         toTarget:<#(nonnull id)#>
                       withObject:<#(nullable id)#> ];

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  [self threadDemo2];
}

#pragma mark - 类方法
- (void)threadDemo2 {
  NSLog(@"before %@", [NSThread currentThread]);

  // detachNewThreadSelector 类方法不需要启动，会自动创建线程并执行@selector方法
  // 它会自动给我们做两件事 :  1.创建线程对象  2.添加到`可调度线程池`
  // 通过NSThread的类和NSObject的分类方法直接加入到可调度线程池里面去,等待CPU调度
  [NSThread detachNewThreadSelector:@selector(longOperation:)
                           toTarget:self
                         withObject:@"DETACH"];

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

- (void)longOperation:(id)obj {
  NSLog(@"%@ - %@", [NSThread currentThread], obj);
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

打印结果：

2016-03-17 18:36:05.339 创建线程2 - 类方法[2647:404930] before <NSThread: 0x7fddf8f01eb0>{number = 1, name = main}
2016-03-17 18:36:05.340 创建线程2 - 类方法[2647:404930] after <NSThread: 0x7fddf8f01eb0>{number = 1, name = main}
2016-03-17 18:36:05.340 创建 线程2 - 类方法[2647:405061] <NSThread: 0x7fddf8e0e7a0>{number = 2, name = (null)} - DETACH

　

4.2-1.3 创建线程3 - 分类方法（NSObject）

创建方式3 : 通过NSObject的分类方法  (隐式创建并直接自动启动线程)   ——推荐,开发常用

// 此方法在后台线程中执行 (即是 : 在子线程中执行)
[self performSelectorInBackground:<#(nonnull SEL) #>
                       withObject:<#(nullable id) #> per];

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  [self threadDemo3];
}

#pragma mark - 分类方法
- (void)threadDemo3 {
  NSLog(@"before %@", [NSThread currentThread]);

  // performSelectorInBackground 是NSObject的分类方法,会自动在后台线程执行@selector方法
  // 没有 thread 字眼，隐式创建并启动线程
  // 所有 NSObject 都可以使用此方法，在其他线程执行方法
  // 通过NSThread的类和NSObject的分类方法直接加入到可调度线程池里面去,等待CPU调度
  // PerformSelectorInBackground 可以让方便地在后台线程执行任意NSObject对象的方法
  [self performSelectorInBackground:@selector(longOperation:)
                         withObject:@"PERFORM"];

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

- (void)longOperation:(id)obj {
  NSLog(@"%@ - %@", [NSThread currentThread], obj);
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

打印结果：

2016-03-17 18:41:58.696 创建线程3 - 分类方法[2711:412522] before <NSThread: 0x7ff078c02320>{number = 1, name = main}
2016-03-17 18:41:58.696 创建线程3 - 分类方法[2711:412522] after <NSThread: 0x7ff078c02320>{number = 1, name = main}
2016-03-17 18:41:58.697 创建线程3 - 分类方法[2711:412751] <NSThread: 0x7ff078c0e390>{number = 2, name = (null)} - PERFORM

　　

方式2和方式3的优缺点 :

优点：简单快捷

缺点：无法对线程进行更详细的设置

4.2-2.0 线程属性

主线程相关方法 :

+ (NSThread *)mainThread; // 获得主线程
- (BOOL)isMainThread; // 是否为主线程
+ (BOOL)isMainThread; // 是否为主线程

NSThread *main = [NSThread mainThread];   // + (NSThread *)mainThread;  获得主线程

[NSThread  isMainThread]; //  + (BOOL)isMainThread;    类方法判断，该方法是否为主线程

[main isMainThread];      //  - (BOOL)isMainThread;   对象方法判断，该对象是否为主线程

其他用法：
(1) currentThread - 获得当前线程 :

举例 :
NSThread *current = [NSThread currentThread]; //获得当前线程

(2) threadPriority - 线程的调度优先级 :

优先级，是一个浮点数，取值范围从 0~1.0　默认优先级是0.5　值越大，优先级越高

优先级高只是保证 CPU 调度的可能性会高

建议：在开发的时候，不要修改优先级
多线程的目的：是将耗时的操作放在后台，不阻塞主线程和用户的交互！
多线程开发的原则：简单

//返回当前方法所在线程的优先级
+ (double)threadPriority;
举例:[NSThread threadPriority];

//设置线程的优先级
+ (BOOL)setThreadPriority:(double)p;
举例:self.thread1.threadPriority = 1.0;

- (double)threadPriority;//返回当前方法所在线程的优先级
- (BOOL)setThreadPriority:(double)p;//设置线程的优先级

(3) name - 线程的名字 :　在大的商业项目中，通常需要在程序崩溃时，获取程序准确执行所在的线程

- (void)setName:(NSString *)n;   //set 方法
- (NSString *)name;              //get 方法

举例:
thread.name = @"线程A";

(4) stackSize - 栈区大小

- 默认情况下，无论是主线程还是子线程，栈区大小都是 512K
- 栈区大小虽然可以设置,但是我们一般都使用系统默认的大小就行了

举例:
[NSThread currentThread].stackSize = 1024 * 1024;

代码示例：

// 线程属性
- (void)threadProperty {
  NSThread *t1 = [[NSThread alloc] initWithTarget:self
                                         selector:@selector(demo)
                                           object:nil];

  // 1. 线程名称
  t1.name = @"Thread AAA";

  // 2. 优先级
  t1.threadPriority = 0;

  [t1 start];

  NSThread *t2 = [[NSThread alloc] initWithTarget:self
                                         selector:@selector(demo)
                                           object:nil];
  // 1. 线程名称
  t2.name = @"Thread BBB";
  // 2. 优先级
  t2.threadPriority = 1;

  [t2 start];
}

- (void)demo {
  for (int i = 0; i < 10; ++i) {
    // 堆栈大小
    NSLog(@"%@ 堆栈大小：%tuK", [NSThread currentThread],[NSThread currentThread].stackSize / 1024);
  }

   // 模拟崩溃
   // 判断是否是主线程
      if (![NSThread currentThread].isMainThread) {
          NSMutableArray *a = [NSMutableArray array];
          [a addObject:nil];
      }
}

4.2-3.0 线程状态/线程生命周期 

• 新建状态
• 就绪状态/启动状态 : 线程在可调度线程池中
• 运行状态
• 阻塞状态/暂停线程 : 线程不在可调度线程池中,但是仍然存在内存中,只是不可用
• 死亡状态 : 线程不在内存中

 

（1）新建状态 : 实例化线程对象

说明：创建线程有多种方式，这里不做过多的介绍

 

 

（2）就绪状态 / 启动线程： ( 进入就绪状态 ->运行状态。当线程任务执行完毕，自动进入死亡状态 )

线程开启 : 线程进入可调度线程池

 

• 向线程对象发送 start 消息，线程对象被加入可调度线程池等待 CPU 调度
• detachNewThreadSelector 方法和 performSelectorInBackground 方法会直接实例化一个线程对象并加入可调度线程池

（3）运行状态：

• CPU 负责调度可调度线程池中线程的执行
• 线程执行完成之前(死亡之前)，状态可能会在就绪和运行之间来回切换
• 就绪和运行之间的状态变化由 CPU 负责，程序员不能干预

• 当 CPU 调度当前线程 , 进入运行状态
• 当 CPU 调度其他线程 , 进入就绪状态

（4）阻塞状态 / 暂停线程 : 当满足某个预定条件时，可以使用休眠或锁阻塞线程执行

方法执行过程，符合某一条件时，可以利用 sleep 方法让线程进入 阻塞 状态

sleepForTimeInterval：    //休眠指定时长    (从现在起睡多少秒)
sleepUntilDate：          //休眠到指定日期 (从现在起睡到指定的日期)
@synchronized(self) { }   //互斥锁

（1）阻塞2秒
[NSThread sleepForTimeInterval:2]; // 阻塞状态

（2）以当前时间为基准阻塞4秒
NSDate *date = [NSDate dateWithTimeIntervalSinceNow:4.0]; //从现在开始多少秒
[NSThread sleepUntilDate:date];  //睡眠多少秒

（5）死亡状态 (一旦线程停止或死亡了，就不能再次开启任务 , 后续的所有代码都不会被执行 )

(1) 正常死亡

• 线程执行完毕

 

(2) 非正常死亡

• (自杀)          当满足某个条件后，在线程内部自己中止执行
• (被逼着死亡) 当满足某个条件后，在主线程给其它线程打个死亡标记(下圣旨),让子线程自行了断.

 

注意：在终止线程之前，应该注意释放之前分配的对象！ 

 

 生命周期示意图：

 

 

 代码示例：

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {

  // 1.在主线程中创建一个子线程(实例化线程对象) ---> 新建状态
  NSThread *Th =
      [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];

  // 2.将 Th 线程加入到可调度线程池,等待CPU调度--->就绪状态
  [Th start];

  // 3.让主线程阻塞,让当前线程(主线程)休眠
  [NSThread sleepForTimeInterval:1.0];

  // 4.在主线程给 Th 线程打死亡标签
  [Th cancel]; //只是打了个标签,并没有执行,需要在子线程中
}

// Th 线程---> 运行状态
- (void)run {

  NSThread *huThread = [NSThread currentThread];

  CGMutablePathRef path = CGPathCreateMutable();

  for (int i = 0; i < 30; i++) {
    if ([huThread isCancelled]) {
      NSLog(@"good bye1");
      return; // --->非正常死亡(被逼着死亡)
    }

    if (i == 5) {
      [NSThread sleepForTimeInterval:3.0]; //--->huThread阻塞状态3秒
      // [NSThread sleepUntilDate:[NSDate distantFuture]]; // 睡到遥远的未来
      // [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]]; //线程睡到从现在开始后的2秒为止
    }

    if ([huThread isCancelled]) {
      NSLog(@"good bye2");
      return;
    }

    if (i == 20) {
      //清空资源
      CGPathRelease(path);

      //在调用下面方法之前,必须清空资源  非正常死亡--自杀（退出线程）
      [NSThread exit];
    }

    if ([huThread isCancelled]) {
      NSLog(@"good bye3");
      return;
    }
    NSLog(@"%d", i);
  }
} //--->huThread死亡状态  (正常死亡状态)

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

4.2-4.1 多线程安全隐患 - 资源共享/抢夺

(1) 起因 : 

 

资源共享概念 : 1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源

 

主要是因为多条线程,对`同一资源同时操作`,导致的问题

(2) 举例 : 比如多个线程访问同一个对象、同一个变量、同一个文件

(3) 结果 : 当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题 (资源强夺)

(4) 解决方案 : 互斥锁 / 同步锁 

代码示例 :  (卖票案例)

多线程开发的复杂度相对较高，在开发时可以按照以下套路编写代码：

• 首先确保单个线程执行正确
• 添加线程

#import "ViewController.h"

@interface ViewController ()
@property(nonatomic, strong) NSThread *thread01; // 售票员01
@property(nonatomic, strong) NSThread *thread02; // 售票员02
@property(nonatomic, strong) NSThread *thread03; // 售票员03

@property(nonatomic, assign) NSInteger ticketCount; //票的总数
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.

  self.ticketCount = 10;

  //创建线程
  self.thread01 = [[NSThread alloc] initWithTarget:self
                                          selector:@selector(saleTicket)
                                            object:nil];
  self.thread01.name = @"售票员01";

  self.thread02 = [[NSThread alloc] initWithTarget:self
                                          selector:@selector(saleTicket)
                                            object:nil];
  self.thread02.name = @"售票员02";

  self.thread03 = [[NSThread alloc] initWithTarget:self
                                          selector:@selector(saleTicket)
                                            object:nil];
  self.thread03.name = @"售票员03";
}

// 开启线程
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  [self.thread01 start];
  [self.thread02 start];
  [self.thread03 start];
}

// 卖票
- (void)saleTicket {

  while (1) {

    @synchronized(self) { //互斥锁（控制器做锁对象）
      // 先取出总数
      NSInteger count = self.ticketCount;

      // 判断还有没有余票
      if (count > 0) {
        self.ticketCount = count - 1;
        NSLog(@"%@卖了一张票，还剩下%zd张", [NSThread currentThread].name,
              self.ticketCount);
      } else {
        NSLog(@"票已经卖完了");
        break;
      }
    }
  }
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

打印结果：

2016-03-17 19:37:27.429 线程安全[3386:472835] 售票员02卖了一张票，还剩下9张
2016-03-17 19:37:27.430 线程安全[3386:472836] 售票员03卖了一张票，还剩下8张
2016-03-17 19:37:27.430 线程安全[3386:472834] 售票员01卖了一张票，还剩下7张
2016-03-17 19:37:27.430 线程安全[3386:472835] 售票员02卖了一张票，还剩下6张
2016-03-17 19:37:27.430 线程安全[3386:472836] 售票员03卖了一张票，还剩下5张
2016-03-17 19:37:27.430 线程安全[3386:472834] 售票员01卖了一张票，还剩下4张
2016-03-17 19:37:27.431 线程安全[3386:472835] 售票员02卖了一张票，还剩下3张
2016-03-17 19:37:27.431 线程安全[3386:472836] 售票员03卖了一张票，还剩下2张
2016-03-17 19:37:27.431 线程安全[3386:472834] 售票员01卖了一张票，还剩下1张
2016-03-17 19:37:27.431 线程安全[3386:472835] 售票员02卖了一张票，还剩下0张
2016-03-17 19:37:27.432 线程安全[3386:472836] 票已经卖完了
2016-03-17 19:37:27.434 线程安全[3386:472834] 票已经卖完了
2016-03-17 19:37:27.434 线程安全[3386:472835] 票已经卖完了

4.2-4.2 安全隐患解决 – 互斥锁 / 同步锁

互斥锁使用技术 : 线程同步

概念：多条线程按顺序地执行任务

引申 : 互斥锁，就是使用了线程同步技术

 

互斥锁使用格式 :

//锁对象为能够加锁的任意 NSObject 对象
//锁对象一定要保证所有的线程都能够访问
//如果代码中只有一个地方需要加锁，大多都使用self，这样可以避免单独再创建一个锁对象
 
@synchronized(锁对象) {
    //需要锁定的代码
}

注意：

• 锁定1份代码只用1把锁，用多把锁是无效的
• 保证锁内的代码，同一时间，只有一条线程能够执行！
• 互斥锁的锁定范围，应该尽量小，锁定范围越大，效率越差！
• 速记 :  [[NSUserDefaults standardUserDefaults] synchronize];

 

互斥锁的使用前提：

多条线程抢夺同一块资源

 

互斥锁的优缺点 :

优点：能有效防止因多线程抢夺资源造成的数据安全问题 , 能保证数据的准确性

缺点：需要消耗大量的CPU资源 , 可能会导致执行速度变慢

 

 

4.2-4.3 原子属性/非原子属性

原子和非原子属性:

(默认) atomic	原子属性	为setter方法加锁	线程安全，需要消耗大量的资源
(推荐) nonatomic	非原子属性	不会为setter方法加锁	非线程安全，适合内存小的移动设备

 

atomic加锁原理：

@property (assign, atomic) int age;
- (void)setAge:(int)age
{
    @synchronized(self) {
        _age = age;
    }
}

 iOS开发的建议：

• 所有属性都声明为nonatomic
• 尽量避免多线程抢夺同一块资源
• 尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力

 

 4.2-5.0 线程间通讯和常用方法

线程间通信：

概念 : 在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信

线程间通信的体现 : 

• 1个线程传递数据给另1个线程
• 在1个线程中执行完特定任务后，转到另1个线程继续执行任务

 

 

线程间通信常用方法 : 

//在主线程执行操作 (从子线程回到主线程)(推荐)
- (void)performSelectorOnMainThread:(SEL)aSelector
                         withObject:(id)arg
                      waitUntilDone:(BOOL)wait;

- (void)performSelector:(SEL)aSelector
               onThread:(NSThread *)thr
             withObject:(id)arg
          waitUntilDone:(BOOL)wait;

另外一种线程之间的通信方式：NSPort（端口）

包括的子类：

（1）NSMessagePort;

（2）NSMachPort;

 

 

4.2-5.1 图片下载示例

#import "ViewController.h"

@interface ViewController ()
@property(weak, nonatomic) IBOutlet UIImageView *imageView;
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  // 开启子线程（在子线程中调用download方法下载图片）
  [self performSelectorInBackground:@selector(download) withObject:nil];
}

#pragma mark - 图片下载
- (void)download {
  // 1.图片的网络路径
  NSURL *url =
      [NSURL URLWithString:@"http://www.5068.com/u/faceimg/20140804114111.jpg"];

  // 2.下载图片并把图片转换为二进制的数据（耗时操作）
  NSData *data = [NSData dataWithContentsOfURL:url];

  // 3.生成图片（把数据转换成图片）
  UIImage *image = [UIImage imageWithData:data];

  // 4.回到主线程中设置图片
  // 方法1：
  [self.imageView
      performSelector:@selector(setImage:)
             onThread:[NSThread mainThread]
           withObject:image
        waitUntilDone:NO]; //是否等到@selector的方法完成后再往下执行，NO表示否

  //方法2：
  [self.imageView performSelectorOnMainThread:@selector(setImage:)
                                   withObject:image
                                waitUntilDone:NO];
  // 方法3：代码一
  [self performSelectorOnMainThread:@selector(showImage:)
                         withObject:image
                      waitUntilDone:NO];
}

// 方法3：代码二
- (void)showImage:(UIImage *)image {
  self.imageView.image = image; //设置显示图片
}

#pragma mark - 测试图片下载时间 方法1：NSDate
- (void)download1 {
  // 1.图片的网络路径
  NSURL *url =
      [NSURL URLWithString:@"http://www.5068.com/u/faceimg/20140804114111.jpg"];

  NSDate *begin = [NSDate date]; //开始时间

  // 2.根据图片的网络路径去下载图片数据
  NSData *data = [NSData dataWithContentsOfURL:url];

  NSDate *end = [NSDate date]; //结束时间

  NSLog(@"%f", [end timeIntervalSinceDate:begin]); // 时间间隔 = 开始-结束

  // 3.显示图片
  self.imageView.image = [UIImage imageWithData:data];
}

#pragma mark - 测试图片下载时间 方法2：CFTimeInterval
- (void)download2 {
  // 1.图片的网络路径
  NSURL *url =
      [NSURL URLWithString:@"http://www.5068.com/u/faceimg/20140804114111.jpg"];

  CFTimeInterval begin = CFAbsoluteTimeGetCurrent(); // 开始时间

  // 2.根据图片的网络路径去下载图片数据
  NSData *data = [NSData dataWithContentsOfURL:url];

  CFTimeInterval end = CFAbsoluteTimeGetCurrent(); //结束时间

  NSLog(@"%f", end - begin); // 时间间隔 = 开始-结束

  // 3.显示图片
  self.imageView.image = [UIImage imageWithData:data];
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

@end

---

如果你觉得本篇文章对你有所帮助，请点击右下部“推荐”，^_^

 

 

作者：蓝田（Loto）
出处：http://www.cnblogs.com/shorfng/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。

 

---

如有疑问，请发送邮件至 shorfng@126.com 联系我。