iOS 多线程学习总结

作者: DinoGuy | 来源:发表于2018-04-24 15:20 被阅读0次

一、基本概念：(多线程是通过提高资源使用率来提高系统总体的效率)

进程：
可以理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，主要管理资源。
线程：
是进程的基本执行单元，一个进程对应多个线程。
主线程：
处理UI，所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程，界面会卡。
多线程：
在同一时刻，一个CPU只能处理1条线程，但CPU可以在多条线程之间快速的切换，只要切换的足够快，就造成了多线程一同执行的假象。
目的：
将耗时的操作放在后台执行

二、线程的状态与生命周期

线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡

线程状态示意图

图1

说明：

新建：
实例化线程对象
就绪：
向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。
运行：
CPU 负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。
阻塞：
当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。
死亡：
正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象
[NSThread exit]：
一旦强行终止线程，后续的所有代码都不会被执行。
[thread cancel]：
并不会直接取消线程，只是给线程对象添加 isCancelled 标记。

三、多线程的四种解决方案

pthread
一套通用的多线程API
适用于 Unix / Linux / Windows 等系统
跨平台/可移植
NSThread
使用更加面向对象
简单易用，可直接操作线程对象
GCD
旨在替代 NSThread 等线程技术
充分利用设备的多核
NSOperation
基于GCD（底层是GCD）
比GCD多了一些更简单实用的功能
使用更加面向对象

方案	语言	线程生命周期	实用频率
pthread	C语言	程序员管理	几乎不用
NSThread	OC语言	程序员管理	偶尔使用
GCD	C语言	自动管理	经常使用
NSOperation	OC语言	自动管理	经常使用

四、线程安全问题

原因：
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题。
解决多线程安全问题的方法：
方法一：互斥锁（同步锁）

@synchronized(锁对象) {
    //需要锁定的代码
}

加了互斥做的代码，当新线程访问时，如果发现其他线程正在执行锁定的代码，新线程就会进入休眠。

注意：
判断的时候锁对象要存在，如果代码中只有一个地方需要加锁，大多都使用self作为锁对象，这样可以避免单独再创建一个锁对象。
锁对象切记不能是局部变量。
方法二：自选锁
加了自旋锁，当新线程访问代码时，如果发现有其他线程正在锁定代码，新线程会用死循环的方式，一直等待锁定的代码执行完成。相当于不停尝试执行代码，比较消耗性能。
属性修饰nonatomic 和 atomic

nonatomic：非原子属性（非线程安全），同一时间可以有很多线程读和写，效率高
atomic：原子属性(线程安全)，保证同一时间只有一个线程能够写入（但是同一个时间多个线程都可以读值）
atomic：本身就有一把自旋锁，且只对写操作进行加锁，对读操作没有限制

五、NSThread的使用

三种创建方式：

initWithTarget / initWithBlock
创建好后，需要通过 start 启动
detachNewThreadSelector / detachNewThreadWithBlock
创建好之后自动启动
performSelectorInBackground
创建好之后自动启动

//方法一
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething:) object:@"NSThread01"];
[thread start];

//方法二
[NSThread detachNewThreadSelector:@selector(doSomething:) toTarget:self withObject:@"NSThread02"];

//方法三
[self performSelectorInBackground:@selector(doSomething:) withObject:@"NSThread03"];

- (void)doSomething:(NSString *) object_str
{
    NSLog(@"参数：%@， 线程：%@", object_str, [NSThread currentThread]);
}

NSThread相关类方法

返回当前线程

// 当前线程
[NSThread currentThread];
NSLog(@"%@", [NSThread currentThread]);
 
// 如果number=1，则表示在主线程，否则是子线程
打印结果：{number = 1, name = main}

阻塞睡眠

//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];

其他

//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];

NSThread相关属性

//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
 thread.threadPriority;

注意：线程优先级和线程执行顺序之间不是必然关系

六、 GCD(Grand Central Dispatch)

Dispatch Queue(队列)

队列种类	说明
串行队列(DISPATCH_QUEUE_SERIAL)	按FIFO的顺序执行，一个任务执行完成才会执行下一个任务
并发队列(DISPATCH_QUEUE_CONCURRENT)	任务无序同时执行

执行方式	说明
同步执行	任务都在当前线程中执行，并且会阻塞当前线程
异步执行	任务会在开辟的新线程中执行，不会阻塞当前线程

组合方式	说明
串行同步队列	任务都在当前线程执行（同步），并且顺序执行（串行）
串行异步队列	任务都在开辟的新的子线程中执行（异步），并且顺序执行（串行）
并发同步队列	任务都在当前线程执行（同步），但是是顺序执行的（并发的特性并没有体现出来）
并发异步队列	任务在开辟的多个子线程中执行（异步），并且是同时执行的（并发）

创建队列：

/**
 串行队列：serial_queue1
 */
dispatch_queue_t serial_queue1 = dispatch_queue_create("com.seral.queue", DISPATCH_QUEUE_SERIAL);
    
/**
 串行队列：serial_queue2
 */
dispatch_queue_t serial_queue2 = dispatch_queue_create("com.seral.queue", NULL);
    
/**
 并发队列：concurrent_queue
 */
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

/**
 主队列（串行队列）：main_queue
 */
dispatch_queue_t main_queue = dispatch_get_main_queue();

/**
 全局队列（并发队列）：global_queue
 */
dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

组合方式说明

(1) 串行同步队列

dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);

dispatch_sync(serial_queue, ^{
    NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(serial_queue, ^{
    NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(serial_queue, ^{
    NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});

结果：

--- 1 --- <NSThread: 0x604000071240>{number = 1, name = main} ---
--- 2 --- <NSThread: 0x604000071240>{number = 1, name = main} ---
--- 3 --- <NSThread: 0x604000071240>{number = 1, name = main} ---

(2) 串行异步队列

dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);

dispatch_async(serial_queue, ^{
    NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
    NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
    NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});

结果：

--- 1 --- <NSThread: 0x60000026f6c0>{number = 3, name = (null)} ---
--- 2 --- <NSThread: 0x60000026f6c0>{number = 3, name = (null)} ---
--- 3 --- <NSThread: 0x60000026f6c0>{number = 3, name = (null)} ---

(3) 并发同步队列

dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_sync(concurrent_queue, ^{
    NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(concurrent_queue, ^{
    NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(concurrent_queue, ^{
    NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});

结果：

--- 1 --- <NSThread: 0x60000006d3c0>{number = 1, name = main} ---
--- 2 --- <NSThread: 0x60000006d3c0>{number = 1, name = main} ---
--- 3 --- <NSThread: 0x60000006d3c0>{number = 1, name = main} ---

(4) 并发异步队列

dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(concurrent_queue, ^{
    NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
    NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
    NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});

结果：

--- 3 --- <NSThread: 0x604000271540>{number = 4, name = (null)} ---
--- 1 --- <NSThread: 0x600000463e40>{number = 3, name = (null)} ---
--- 2 --- <NSThread: 0x600000279b80>{number = 5, name = (null)} ---

队列组

作用：队列组是用来管理队列中任务的执行

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_group_async(group, concurrent_queue, ^{
    NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_group_async(group, concurrent_queue, ^{
    NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_group_async(group, concurrent_queue, ^{
    NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});

dispatch_group_notify(group, concurrent_queue, ^{
    NSLog(@"到这里就结束了！");
});

结果：

--- 2 --- <NSThread: 0x600000273300>{number = 8, name = (null)} ---
--- 3 --- <NSThread: 0x600000273640>{number = 3, name = (null)} ---
--- 1 --- <NSThread: 0x600000264840>{number = 7, name = (null)} ---

Barrier

(1) 通过 barrier 添加的 block ，会等其之前添加的所有 block 执行完毕再执行
(2) 在 barrier 之后添加的 block ,会等其添加的 block 执行完毕再执行
(3) 只在自定义创建的并发队列有效

dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});

/**
 此处使用 dispatch_barrier_sync，block任务在当前线程中执行
 */
dispatch_barrier_async(concurrent_queue, ^{
    NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});

dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(concurrent_queue, ^{
    NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});

结果：

--- reading 2 --- <NSThread: 0x60400027b100>{number = 11, name = (null)} ---
--- reading 1 --- <NSThread: 0x60000026fb00>{number = 13, name = (null)} ---
--- reading 3 --- <NSThread: 0x600000270040>{number = 14, name = (null)} ---
--- writing 0 --- <NSThread: 0x600000270040>{number = 14, name = (null)} ---
--- reading 5 --- <NSThread: 0x60000026fb00>{number = 13, name = (null)} ---
--- reading 4 --- <NSThread: 0x600000270040>{number = 14, name = (null)} ---
--- reading 6 --- <NSThread: 0x60400027b100>{number = 11, name = (null)} ---

全局队列中：

dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(global_queue, ^{
    NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(global_queue, ^{
    NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(global_queue, ^{
    NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});

dispatch_barrier_async(global_queue, ^{
    NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});

dispatch_async(global_queue, ^{
    NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(global_queue, ^{
    NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(global_queue, ^{
    NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});

结果：

--- reading 1 --- <NSThread: 0x60000026aa80>{number = 12, name = (null)} ---
--- reading 2 --- <NSThread: 0x60000007d780>{number = 10, name = (null)} ---
--- writing 0 --- <NSThread: 0x60000026ad00>{number = 11, name = (null)} ---
--- reading 3 --- <NSThread: 0x60000007f340>{number = 13, name = (null)} ---
--- reading 4 --- <NSThread: 0x60400026c640>{number = 6, name = (null)} ---
--- reading 5 --- <NSThread: 0x60000026b000>{number = 8, name = (null)} ---
--- reading 6 --- <NSThread: 0x60000026b140>{number = 7, name = (null)} ---

串行队列中：

dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);

dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});

dispatch_barrier_async(serial_queue, ^{
    NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});

dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(serial_queue, ^{
    NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});

结果：

--- reading 1 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- reading 2 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- reading 3 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- writing 0 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- reading 4 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- reading 5 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---
--- reading 6 --- <NSThread: 0x604000268e00>{number = 4, name = (null)} ---

Semaphore （信号量）

/**
 创建方法：初始值必须 >= 0
 */
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

/**
 等待一个信号
 DISPATCH_TIME_NOW ：不等待
 DISPATCH_TIME_FOREVER ：一直等待，直到收到信号
 返回 0 为成功，非 0 就是超时
 */
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

/**
 发送信号：信号量计数增加
 */
dispatch_semaphore_signal(semaphore);

实例1：多个网络请求并发执行

dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

dispatch_group_async(group, global_queue, ^{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        dispatch_semaphore_signal(semaphore);
        NSLog(@"--- 请求 1 ---");
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, global_queue, ^{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        dispatch_semaphore_signal(semaphore);
        NSLog(@"--- 请求 2 ---");
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, global_queue, ^{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        dispatch_semaphore_signal(semaphore);
        NSLog(@"--- 请求 3 ---");
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});

dispatch_group_notify(group, global_queue, ^{
    NSLog(@"--- 请求全部完成! ---");
});

结果：

--- 请求 3 ---
--- 请求 2 ---
--- 请求 1 ---
--- 请求全部完成! ---

实例2：多个网络请求顺序执行

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_queue_t serial_queue = dispatch_queue_create("com.serial_queue", NULL);

dispatch_async(serial_queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"--- 请求 1 ---");
        dispatch_semaphore_signal(semaphore);

    });
});
dispatch_async(serial_queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"--- 请求 2 ---");
        dispatch_semaphore_signal(semaphore);

    });
});
dispatch_async(serial_queue, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"--- 请求 3 ---");
        dispatch_semaphore_signal(semaphore);
    });
});

结果：

--- 请求 1 ---
--- 请求 2 ---
--- 请求 3 ---

GitHub地址：Demo

iOS 多线程学习总结

一、基本概念：(多线程是通过提高资源使用率来提高系统总体的效率)

二、线程的状态与生命周期

三、多线程的四种解决方案

四、线程安全问题

五、NSThread的使用

六、 GCD(Grand Central Dispatch)

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读