iOS多线程的一些总结和理解

2015-12-07 本文已影响1925人 i_Leechee

线程

一个线程中任务的执行是串行的
同一时间内，一个线程只能执行一个任务
线程是进程中的一条执行路径

多线程

一个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务

多线程原理

同一时间，CPU只能处理1条线程，只有一条线程在工作（执行）
多线程并发（同时）执行，其实是CPU快速在多条线程之间调度（切换）
多核CPU是真正意义上的多线程

CPU在多个线程之间调度，会消耗大量的CPU资源
每条线程被调度执行的频次会降低（线程执行效率会降低）

优点：

能适当提高程序的执行效率

缺点：

创建线程是有开销的，iOS下主要成本包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB）
也可以使用-setStackSize设置，但必须是4K的倍数，而且最小为16K，创建线程大约需要90毫秒的创建时间
开启大量的线程，会降低程序的性能
线程越多，CPU在调度线程上的开销越大
程序设计更加复杂：比如线程之间的通信、多线程的数据共享

多线程在iOS中的应用

一个iOS程序运行后，默认开启一个线程，称为主线程或UI线程

主线程的作用：

显示、刷新UI界面
处理UI事件（点击、滚动、拖拽事件等）

多线程使用注意：

别将比较耗时的操作放到主线程中，耗时操作会卡住主线程，严重影响UI流畅度

iOS多线程实现方案

pthread C 通用的多线程API，跨平台，程序员手动管理线程生命周期，使用难度大，iOS中几乎不用
NSThread OC 面向对象，简单易用，只负责创建，不用管理线程死亡，偶尔使用
GCD C 替代NSThread等线程技术，可以充分利用设备的多核，线程生命周期自动管理，经常使用
NSOperation OC 基于GCD（底层是GCD），比GCD多了一些简单实用的功能，更加面向对象，自动管理线程生命周期，经常使用。

pthread

需要引入#import <pthread.h>

//创建方法
int pthread_create(pthread_t * __restrict, const pthread_attr_t * __restrict,
        void *(*)(void *), void * __restrict);

//使用
 pthread_t thread;
 pthread_create(&thread, NULL, func, NULL);

void * func(void *param)
{
    for (NSInteger i = 0; i<50000; i++) {
        NSLog(@"----%zd--%@", i, [NSThread currentThread]);
    }
    return NULL;
}

NSThread

创建、启动线程

方法一

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(func) object:nil];
[thread start];
//线程启动时，就会在线程thread中执行self中的func方法

方法二

//创建线程后自动启动线程
[NSThread detachNewThreadSelector:(SEL) toTarget:(id) withObject:(id)];

方法三

//隐式创建并启动线程
[self performSelectorInBackground:(SEL) withObject:(id)];

主线程相关用法：

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

线程阻塞：

+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;

线程死亡：

- (void)exit; // 强制退出线程

GCD

会自动利用更多的CPU内核，会自动管理线程的生命周期，不需要写管理线程的代码。定制任务将任务添加到队列中 GCD会自动将队列中的任务取出，放到线程中去执行，任务的取出遵循FIFO原则。

任务 (是否有开启新线程的能力)

同步
在当前线程中执行

dispatch_sync(dispatch_queue_t queue, ^(void)block)

异步
可以在新的线程中执行,有开新线程的能力（不是一定会开新线程，比如放在主队列中）

dispatch_async(dispatch_queue_t queue, ^(void)block)

队列 (影响任务的执行方式)

并发（允许开启多个线程）

// 创建并发队列
 dispatch_queue_t queue = dispatch_queue_create("queue.com", DISPATCH_QUEUE_CONCURRENT);

串行

// 创建串行队列
 dispatch_queue_t queue = dispatch_queue_create("queue.com", DISPATCH_QUEUE_SERIAL);
//  DISPATCH_QUEUE_SERIAL 可以传NULL

获取全局并发队列

// 两个参数  优先级 保留参数传0
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

获取全局串行主队列(主队列中的任务都在主线程中执行)

dispatch_queue_t queue = dispatch_get_main_queue();

不可以在主队列中添加同步任务，因为同步任务立刻会执行，选成死锁

| | 并发队列 | 手动创建的串行队列 | 主队列|
| ------------- |:-------------:| -----:|
| 同步sync |没有开启新线程串行执行任务|没有开启新线程串行执行任务|没有开启新线程串行执行任务|
| 异步async |有开启新线程并发执行任务|有开启新线程串行执行任务|没有开启新线程串行执行任务|

GCD一些方法示例

/** 并发 异步 全局并发队列 */
- (void)GCDTest1 {
    /**
     @param identifier 优先级
     @param flags      保留参数 默认传0
     */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, ^{
        NSLog(@"-------1-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------2-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------3-------");
    });
}

/** 并发 异步 自定义并发队列 */
- (void)GCDTest2 {
    dispatch_queue_t queue = dispatch_queue_create("queue.com", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"-------1-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------2-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------3-------");
    });
}

/** 并发 异步 自定义并发队列 围栏函数 */
- (void)GCDTest3 {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, ^{
        NSLog(@"-------1-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------2-------");
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"-------围栏函数-------");
    });
    dispatch_async(queue, ^{
        NSLog(@"-------3-------");
    });
}

/** 利用一次性函数写单列 */
+ (instancetype)GCDTest4 {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _singleton = [[Singleton alloc] init];
    });
    return _singleton;
}

/** 延迟执行 */
- (void)GCDTest5 {
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"延时2秒打印");
    });
}

/** GCD group */
- (void)GCDTest6 {
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"-------1-------");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"-------2-------");
    });
    dispatch_group_notify(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"-------3-------");
    });
}

多线程的安全隐患

资源共享：
一块资源可能会被多个线程共享，比如多个线程访问同一个对象、对一个变量、同一个文件

解决方法：

互斥锁
@synchronized(锁对象){ //需要锁定的代码 }
不推荐使用，消耗性能
锁定1份代码只能用1把锁，用多把是无效的
线程同步技术

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

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

线程之间的通信

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

如：
一个线程传递数据给另一个线程
在一个线程中执行完特定任务后，转到另一个线程中继续执行任务
常用方法：

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

NSPort 端口对象 在两个线程之间通信
NSMessagePort
NSMachPort