iOS多线程编程之NSThread的使用（★★★推荐，为原作者点赞★★★）

文章来源：http://blog.csdn.net/totogo2010/article/details/8010231

1、简介：

1.1 iOS有三种多线程编程的技术，分别是：

1.、NSThread 

2、Cocoa NSOperation （iOS多线程编程之NSOperation和NSOperationQueue的使用）

3、GCD  全称：Grand Central Dispatch（ iOS多线程编程之Grand Central Dispatch(GCD)介绍和使用）

这三种编程方式从上到下，抽象度层次是从低到高的，抽象度越高的使用越简单，也是Apple最推荐使用的。

这篇我们主要介绍和使用NSThread，后面会继续2、3 的讲解和使用。

1.2 三种方式的有缺点介绍：

NSThread:

优点：NSThread 比其他两个轻量级

缺点：需要自己管理线程的生命周期，线程同步。线程同步对数据的加锁会有一定的系统开销

NSThread实现的技术有下面三种：

Technology	Description
Cocoa threads	Cocoa implements threads using the NSThread class. Cocoa also provides methods on NSObject for spawning new threads and executing code on already-running threads. For more information, see “Using NSThread” and “Using NSObject to Spawn a Thread.”
POSIX threads	POSIX threads provide a C-based interface for creating threads. If you are not writing a Cocoa application, this is the best choice for creating threads. The POSIX interface is relatively simple to use and offers ample flexibility for configuring your threads. For more information, see “Using POSIX Threads”
Multiprocessing Services	Multiprocessing Services is a legacy C-based interface used by applications transitioning from older versions of Mac OS. This technology is available in OS X only and should be avoided for any new development. Instead, you should use the NSThread class or POSIX threads. If you need more information on this technology, see Multiprocessing Services Programming Guide.

一般使用cocoa thread 技术。

Cocoa operation 

优点：不需要关心线程管理，数据同步的事情，可以把精力放在自己需要执行的操作上。

Cocoa operation 相关的类是 NSOperation ，NSOperationQueue。NSOperation是个抽象类，使用它必须用它的子类，可以实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。创建NSOperation子类的对象，把对象添加到NSOperationQueue队列里执行。

GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。在iOS4.0开始之后才能使用。GCD是一个替代诸如NSThread, NSOperationQueue, NSInvocationOperation等技术的很高效和强大的技术。现在的iOS系统都升级到6了，所以不用担心该技术不能使用。

介绍完这三种多线程编程方式，我们这篇先介绍NSThread的使用。

2、NSThread的使用

2.1 NSThread 有两种直接创建方式：

- (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument

+ (void)detachNewThreadSelector:(SEL)aSelector toTarget:(id)aTarget withObject:(id)anArgument

第一个是实例方法，第二个是类方法

[cpp]  view plain copy

1. 1、[NSThread detachNewThreadSelector:@selector(doSomething:) toTarget:self withObject:nil];  
2. 2、NSThread* myThread = [[NSThread alloc] initWithTarget:self  
3.                                         selector:@selector(doSomething:)  
4.                                         object:nil];  
5. [myThread start];  

2.2参数的意义：

selector ：线程执行的方法，这个selector只能有一个参数，而且不能有返回值。

target  ：selector消息发送的对象

argument:传输给target的唯一参数，也可以是nil

第一种方式会直接创建线程并且开始运行线程，第二种方式是先创建线程对象，然后再运行线程操作，在运行线程操作前可以设置线程的优先级等线程信息

2.3 PS:不显式创建线程的方法：

用NSObject的类方法  performSelectorInBackground:withObject: 创建一个线程：
[Obj performSelectorInBackground:@selector(doSomething) withObject:nil];

2.4 下载图片的例子：

2.4.1  新建singeView app

新建项目，并在xib文件上放置一个imageView控件。按住control键拖到viewControll

er.h文件中创建imageView IBOutlet 

ViewController.m中实现：

[cpp]  view plain copy

1. //  
2. //  ViewController.m  
3. //  NSThreadDemo  
4. //  
5. //  Created by rongfzh on 12-9-23.  
6. //  Copyright (c) 2012年 rongfzh. All rights reserved.  
7. //  
8.   
9. #import "ViewController.h"  
10. #define kURL @"http://avatar.csdn.net/2/C/D/1_totogo2010.jpg"  
11. @interface ViewController ()  
12.   
13. @end  
14.   
15. @implementation ViewController  
16.   
17. -(void)downloadImage:(NSString *) url{  
18.     NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:url]];  
19.     UIImage *image = [[UIImage alloc]initWithData:data];  
20.     if(image == nil){  
21.           
22.     }else{  
23.         [self performSelectorOnMainThread:@selector(updateUI:) withObject:image waitUntilDone:YES];  
24.     }  
25. }  
26.   
27. -(void)updateUI:(UIImage*) image{  
28.     self.imageView.image = image;  
29. }  
30.   
31.   
32. - (void)viewDidLoad  
33. {  
34.     [super viewDidLoad];  
35.       
36. //    [NSThread detachNewThreadSelector:@selector(downloadImage:) toTarget:self withObject:kURL];  
37.     NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(downloadImage:) object:kURL];  
38.     [thread start];  
39. }  
40.   
41. - (void)didReceiveMemoryWarning  
42. {  
43.     [super didReceiveMemoryWarning];  
44.     // Dispose of any resources that can be recreated.  
45. }  
46.   
47. @end  

2.4.2线程间通讯

线程下载完图片后怎么通知主线程更新界面呢？

[self performSelectorOnMainThread:@selector(updateUI:) withObject:image waitUntilDone:YES];

performSelectorOnMainThread是NSObject的方法，除了可以更新主线程的数据外，还可以更新其他线程的比如：

用：performSelector:onThread:withObject:waitUntilDone: 

运行下载图片：

图片下载下来了。

2.3 线程同步

我们演示一个经典的卖票的例子来讲NSThread的线程同步：

.h

[cpp]  view plain copy

1. #import <UIKit/UIKit.h>  
2.   
3. @class ViewController;  
4.   
5. @interface AppDelegate : UIResponder <UIApplicationDelegate>  
6. {  
7.     int tickets;  
8.     int count;  
9.     NSThread* ticketsThreadone;  
10.     NSThread* ticketsThreadtwo;  
11.     NSCondition* ticketsCondition;  
12.     NSLock *theLock;  
13. }  
14. @property (strong, nonatomic) UIWindow *window;  
15.   
16. @property (strong, nonatomic) ViewController *viewController;  
17.   
18. @end  

[cpp]  view plain copy

1. - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions  
2. {  
3.       
4.     tickets = 100;  
5.     count = 0;  
6.     theLock = [[NSLock alloc] init];  
7.     // 锁对象  
8.     ticketsCondition = [[NSCondition alloc] init];  
9.     ticketsThreadone = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];  
10.     [ticketsThreadone setName:@"Thread-1"];  
11.     [ticketsThreadone start];  
12.       
13.       
14.     ticketsThreadtwo = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];  
15.     [ticketsThreadtwo setName:@"Thread-2"];  
16.     [ticketsThreadtwo start];  
17.       
18.     self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];  
19.     // Override point for customization after application launch.  
20.     self.viewController = [[ViewController alloc] initWithNibName:@"ViewController" bundle:nil];  
21.     self.window.rootViewController = self.viewController;  
22.     [self.window makeKeyAndVisible];  
23.     return YES;  
24. }  
25.   
26. - (void)run{  
27.     while (TRUE) {  
28.         // 上锁  
29. //        [ticketsCondition lock];  
30.         [theLock lock];  
31.         if(tickets >= 0){  
32.             [NSThread sleepForTimeInterval:0.09];  
33.             count = 100 - tickets;  
34.             NSLog(@"当前票数是:%d,售出:%d,线程名:%@",tickets,count,[[NSThread currentThread] name]);  
35.             tickets--;  
36.         }else{  
37.             break;  
38.         }  
39.         [theLock unlock];  
40. //        [ticketsCondition unlock];  
41.     }  
42. }  

如果没有线程同步的lock，卖票数可能是-1.加上lock之后线程同步保证了数据的正确性。
上面例子我使用了两种锁，一种NSCondition ，一种是：NSLock。 NSCondition我已经注释了。

线程的顺序执行

他们都可以通过

        [ticketsCondition signal]; 发送信号的方式，在一个线程唤醒另外一个线程的等待。

比如：

[cpp]  view plain copy

1. #import "AppDelegate.h"  
2.   
3. #import "ViewController.h"  
4.   
5. @implementation AppDelegate  
6.   
7. - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions  
8. {  
9.       
10.     tickets = 100;  
11.     count = 0;  
12.     theLock = [[NSLock alloc] init];  
13.     // 锁对象  
14.     ticketsCondition = [[NSCondition alloc] init];  
15.     ticketsThreadone = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];  
16.     [ticketsThreadone setName:@"Thread-1"];  
17.     [ticketsThreadone start];  
18.       
19.     ticketsThreadtwo = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];  
20.     [ticketsThreadtwo setName:@"Thread-2"];  
21.     [ticketsThreadtwo start];  
22.       
23.     NSThread *ticketsThreadthree = [[NSThread alloc] initWithTarget:self selector:@selector(run3) object:nil];  
24.     [ticketsThreadthree setName:@"Thread-3"];  
25.     [ticketsThreadthree start];      
26.     self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];  
27.     // Override point for customization after application launch.  
28.     self.viewController = [[ViewController alloc] initWithNibName:@"ViewController" bundle:nil];  
29.     self.window.rootViewController = self.viewController;  
30.     [self.window makeKeyAndVisible];  
31.     return YES;  
32. }  
33.   
34. -(void)run3{  
35.     while (YES) {  
36.         [ticketsCondition lock];  
37.         [NSThread sleepForTimeInterval:3];  
38.         [ticketsCondition signal];  
39.         [ticketsCondition unlock];  
40.     }  
41. }  
42.   
43. - (void)run{  
44.     while (TRUE) {  
45.         // 上锁  
46.         [ticketsCondition lock];  
47.         [ticketsCondition wait];  
48.         [theLock lock];  
49.         if(tickets >= 0){  
50.             [NSThread sleepForTimeInterval:0.09];  
51.             count = 100 - tickets;  
52.             NSLog(@"当前票数是:%d,售出:%d,线程名:%@",tickets,count,[[NSThread currentThread] name]);  
53.             tickets--;  
54.         }else{  
55.             break;  
56.         }  
57.         [theLock unlock];  
58.         [ticketsCondition unlock];  
59.     }  
60. }  

wait是等待，我加了一个 线程3 去唤醒其他两个线程锁中的wait

其他同步

我们可以使用指令 @synchronized 来简化 NSLock的使用，这样我们就不必显示编写创建NSLock,加锁并解锁相关代码。
- (void)doSomeThing:(id)anObj
{
    @synchronized(anObj)
    {
        // Everything between the braces is protected by the @synchronized directive.
    }
}
还有其他的一些锁对象，比如：循环锁NSRecursiveLock，条件锁NSConditionLock，分布式锁NSDistributedLock等等,可以自己看官方文档学习

NSThread下载图片的例子代码：http://download.csdn.net/detail/totogo2010/4591149

著作权声明：本文由http://blog.csdn.net/totogo2010/原创，欢迎转载分享。请尊重作者劳动，转载时保留该声明和作者博客链接，谢谢!

附录一、如何在子线程更新主线程UI

在iphone开发中经常需要更新UI的显示，一般需要启动新的线程来运行相关数据地更新，然后在另一线程中更新UI. 这里利用NSThread实现这样一个功能：更新进度条。
复制代码
//
// NSThreadDemoAppDelegate.m
// NSThreadDemo
//
// Created by Chelsea Wang(420989762/wwssttt@163.com) on 11-10-11.
// Copyright 2011年 __MyCompanyName__. All rights reserved.
//

@implementation NSThreadDemoAppDelegate
float processValue = 0;
@synthesize window = _window;

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
// Override point for customization after application launch.
UIProgressView* processView = [[UIProgressView alloc] initWithProgressViewStyle:UIProgressViewStyleDefault];
[processView setFrame:CGRectMake(10, 50, 200, 30)];
[processView setTag:101];
[processView setProgress:0.0];

UILabel* processLabel = [[UILabel alloc] initWithFrame:CGRectMake(225, 30, 100, 50)];
[processLabel setText:[NSString stringWithFormat:@"%.2f%%",processValue*100]];
[processLabel setTag:102];

[self.window addSubview:processView];
[processView release];
[self.window addSubview:processLabel];
[processLabel release];
[self.window makeKeyAndVisible];

[NSThread detachNewThreadSelector:@selector(updateProcess) toTarget:self withObject:nil];
return YES;
}

-(void)updateProcess{
NSAutoreleasePool* p = [[NSAutoreleasePool alloc] init];
[self performSelectorOnMainThread:@selector(updateUI) withObject:nil waitUntilDone:YES];
[p release];
}
-(void)updateUI{
if (processValue <= 1.0) {
processValue += 0.1;

UIProgressView* processView = (UIProgressView*)[self.window viewWithTag:101];
[processView setProgress:processValue];

UILabel* processLabel = (UILabel*)[self.window viewWithTag:102];
[processLabel setText:[NSString stringWithFormat:@"%.2f%%",processValue*100]];

[NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(updateUI) userInfo:nil repeats:NO];
}else{
processValue = 0.0;
[NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(updateUI) userInfo:nil repeats:NO];
}
}

附录二、线程间通信

线程在运行过程中，可能须要与其它线程进行通信。我们可以应用 NSObject 中的一些办法：
在应用法度主线程中做工作：
performSelectorOnMainThread:withObject:waitUntilDone:
performSelectorOnMainThread:withObject:waitUntilDone:modes:

在指定线程中做工作：
performSelector:onThread:withObject:waitUntilDone:
performSelector:onThread:withObject:waitUntilDone:modes:

在当前线程中做工作：
performSelector:withObject:afterDelay:
performSelector:withObject:afterDelay:inModes:

作废发送给当前线程的某个消息：
cancelPreviousPerformRequestsWithTarget:
cancelPreviousPerformRequestsWithTarget:or:object:

如在我们在某个线程中数据，完成之后要通知主线程中更新界面等等，可以应用如下接口：

- （void）myThreadMainMethod
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    // to do something in your thread job
    ...
    [self performSelectorOnMainThread:＠or（UI） withObject:nil waitUntilDone:NO];
    [pool release];
}

附录三、RunLoop
说到 NSThread 就不克不及不说起与之关系相当慎密的 NSRunLoop。Run loop 相当于 win32 里面的消息轮回机制，它可以让你按照事务/消息（鼠标消息，键盘消息，计时器消息等）来调剂线程是繁忙还是闲置。体系会主动为应用法度的主线程生成一个与之对应的 run loop 来处理惩罚其消息轮回。在触摸 UIView 时之所以可以或许激发 touchesBegan/touchesMoved 等等函数被调用，就是因为应用法度的主线程在 UIApplicationMain 里面有如许一个 run loop 在分发 input 或 timer 事务。

1.什么是NSRunLoop？

我们会经常看到这样的代码：

- (IBAction)start:(id)sender

{

pageStillLoading = YES;

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

[progress setHidden:NO];

while (pageStillLoading) {

[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];

}

[progress setHidden:YES];

}

这段代码很神奇的，因为他会“暂停”代码运行，而且程序运行不会因为这里有一个while循环而受到影响。在[progress setHidden:NO]执行之后，整个函数想暂停了一样停在循环里面，等loadPageInBackground里面的操作都完成了以后才让[progress setHidden:YES]运行。这样做就显得简介，而且逻辑很清晰。如果你不这样做，你就需要在loadPageInBackground里面表示load完成的地方调用[progress setHidden:YES]，显得代码不紧凑而且容易出错。

那么具体什么是NSRunLoop呢？其实NSRunLoop的本质是一个消息机制的处理模式。如果你对vc++编程有一定了解，在windows中，有一系列很重要的函数SendMessage，PostMessage，GetMessage，这些都是有关消息传递处理的API。但是在你进入到Cocoa的编程世界里面，我不知道你是不是走的太快太匆忙而忽视了这个很重要的问题，Cocoa里面就没有提及到任何关于消息处理的API，开发者从来也没有自己去关心过消息的传递过程，好像一切都是那么自然，像大自然一样自然？在Cocoa里面你再也不用去自己定义WM_COMMAD_XXX这样的宏来标识某个消息，也不用在switch-case里面去对特定的消息做特别的处理。难道是Cocoa里面就没有了消息机制？答案是否定的，只是Apple在设计消息处理的时候采用了一个更加高明的模式，那就是RunLoop。

2. NSRunLoop工作原理

接下来看一下NSRunLoop具体的工作原理，首先是官方文档提供的说法，看图：

通过所有的“消息”都被添加到了NSRunLoop中去，而在这里这些消息并分为“input source”和“Timer source” 并在循环中检查是不是有事件需要发生，如果需要那么就调用相应的函数处理。为了更清晰的解释，我们来对比VC++和iOS消息处理过程。

VC++中在一切初始化都完成之后程序就开始这样一个循环了（代码是从户sir mfc程序设计课程的slides中截取）：

int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow){

...

while (GetMessage(&msg, NULL, 0, 0)){

if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)){

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

}

可以看到在GetMessage之后就去分发处理消息了，而iOS中main函数中只是调用了UIApplicationMain，那么我们可以介意猜出UIApplicationMain在初始化完成之后就会进入这样一个情形：

int UIApplicationMain(...){

...

while(running){

[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];

}

...

}

所以在UIApplicationMain中也是同样在不断处理runloop才是的程序没有退出。刚才的我说了NSRunLoop是一种更加高明的消息处理模式，他就高明在对消息处理过程进行了更好的抽象和封装，这样才能是的你不用处理一些很琐碎很低层次的具体消息的处理，在NSRunLoop中每一个消息就被打包在input source或者是timer source中了，当需要处理的时候就直接调用其中包含的相应对象的处理函数了。所以对外部的开发人员来讲，你感受到的就是，把source/timer加入到runloop中，然后在适当的时候类似于[receiver action]这样的事情发生了。甚至很多时候，你都没有感受到整个过程前半部分，你只是感觉到了你的某个对象的某个函数调用了。比如在UIView被触摸时会用touchesBegan/touchesMoved等等函数被调用，也许你会想，“该死的，我都不知道在那里被告知有触摸消息，这些处理函数就被调用了！？”所以，消息是有的，只是runloop已经帮你做了！为了证明我的观点，我截取了一张debug touchesBegan的call stack，有图有真相：

 

现在会过头来看看刚才的那个会“暂停”代码的例子，有没有更加深入的认识了呢？