iOS Objective-C 基础 (三) - 多线程

iOS May 23, 2015

NSThread

这个应该是用起来最简单的了，官方文档这么写的

/*	NSThread.h
	Copyright (c) 1994-2014, Apple Inc. All rights reserved.
*/

#import <Foundation/NSObject.h>
#import <Foundation/NSDate.h>

@class NSArray, NSMutableDictionary, NSDate;

@interface NSThread : NSObject  {
@private
    id _private;
    uint8_t _bytes[44];
}

+ (NSThread *)currentThread;

+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;

+ (BOOL)isMultiThreaded;

@property (readonly, retain) NSMutableDictionary *threadDictionary;

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

+ (void)exit;

+ (double)threadPriority;
+ (BOOL)setThreadPriority:(double)p;

@property double threadPriority NS_AVAILABLE(10_6, 4_0); // To be deprecated; use qualityOfService below

@property NSQualityOfService qualityOfService NS_AVAILABLE(10_10, 8_0); // read-only after the thread is started

+ (NSArray *)callStackReturnAddresses NS_AVAILABLE(10_5, 2_0);
+ (NSArray *)callStackSymbols NS_AVAILABLE(10_6, 4_0);

@property (copy) NSString *name NS_AVAILABLE(10_5, 2_0);

@property NSUInteger stackSize NS_AVAILABLE(10_5, 2_0);

@property (readonly) BOOL isMainThread NS_AVAILABLE(10_5, 2_0);
+ (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0); // reports whether current thread is main
+ (NSThread *)mainThread NS_AVAILABLE(10_5, 2_0);

- (instancetype)init NS_AVAILABLE(10_5, 2_0) NS_DESIGNATED_INITIALIZER;
- (instancetype)initWithTarget:(id)target selector:(SEL)selector object:(id)argument NS_AVAILABLE(10_5, 2_0);

@property (readonly, getter=isExecuting) BOOL executing NS_AVAILABLE(10_5, 2_0);
@property (readonly, getter=isFinished) BOOL finished NS_AVAILABLE(10_5, 2_0);
@property (readonly, getter=isCancelled) BOOL cancelled NS_AVAILABLE(10_5, 2_0);

- (void)cancel NS_AVAILABLE(10_5, 2_0);

- (void)start NS_AVAILABLE(10_5, 2_0);

- (void)main NS_AVAILABLE(10_5, 2_0);	// thread body method

@end

FOUNDATION_EXPORT NSString * const NSWillBecomeMultiThreadedNotification;
FOUNDATION_EXPORT NSString * const NSDidBecomeSingleThreadedNotification;
FOUNDATION_EXPORT NSString * const NSThreadWillExitNotification;

@interface NSObject (NSThreadPerformAdditions)

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
	// equivalent to the first method with kCFRunLoopCommonModes

- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);
	// equivalent to the first method with kCFRunLoopCommonModes
- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg NS_AVAILABLE(10_5, 2_0);

@end

常用的方法有

// 新开一个线程
[[NSThread alloc] initWithTarget:self selector:@selector(threadTest) object:nil];

// 启动线程
[thread start];

// 类方法创建一个线程
[NSThread detachNewThreadSelector:@selector(threadTest) toTarget:self withObject:nil];

// 隐式创建一个线程
[self performSelectorInBackground:@selector(threadTest) withObject:nil];

// 获取当前线程
[NSThread currentThread];

// 获取主线程
[NSThread mainThread];

// 当前线程暂停两秒
[NSThread sleepForTimeInterval:2.0];
// 或者
NSDate *date = [NSDate dateWithTimeInterval:2 sinceDate:[NSDate date]];
[NSThread sleepUntilDate:date];

// 在主线程上执行一个操作
[self performSelectorOnMainThread:@selector(threadTest) withObject:nil waitUntilDone:YES];

// 在指定线程上执行一个操作
[self performSelector:@selector(threadTest) onThread:thread withObject:nil waitUntilDone:YES];

// 在当前线程执行一个操作
[self performSelector:@selector(threadTest) withObject:nil];

所以新建一个线程、执行一些操作，都是很简单的，就不上代码了 = =

需要注意的是，主线程会占用 1M 的栈区空间，新开的线程会占用 512K 的栈区空间，新开的线程可以暂停，可以休眠，但是杀不掉，系统自己会回收这个空间。

NSOperation

然而并不是怎么想写 ╭(╯^╰)╮。主要是另外两个完全满足我需求了，遂懒得研究别的。

本着认(ren)真(jian)负(bu)责(chai)的态度，顺手复制点吧 = =，没有亲测，可不可靠自行测试！

下面来自李明杰老师的博客。

NSOperation

1.简介

NSOperation 实例封装了需要执行的操作和执行操作所需的数据，并且能够以并发或非并发的方式执行这个操作。

NSOperation 本身是抽象基类，因此必须使用它的子类，使用 NSOperation 子类的方式有 2 种：

1> Foundation 框架提供了两个具体子类直接供我们使用：NSInvocationOperation 和 NSBlockOperation

2> 自定义子类继承 NSOperation，实现内部相应的方法

2.执行操作

NSOperation 调用 start 方法即可开始执行操作，NSOperation 对象默认按同步方式执行，也就是在调用 start 方法的那个线程中直接执行。NSOperation 对象的 isConcurrent 方法会告诉我们这个操作相对于调用 start 方法的线程，是同步还是异步执行。isConcurrent 方法默认返回 NO，表示操作与调用线程同步执行。

3.取消操作

operation 开始执行之后，默认会一直执行操作直到完成，我们也可以调用 cancel 方法中途取消操作

[operation cancel];

4.监听操作的执行

如果我们想在一个 NSOperation 执行完毕后做一些事情，就调用 NSOperation 的 setCompletionBlock 方法来设置想做的事情。

operation.completionBlock = ^() {
    NSLog(@"执行完毕");
};

// 或者
[operation setCompletionBlock:^() {
    NSLog(@"执行完毕");
}];

NSInvocationOperation

1.简介

基于一个对象和 selector 来创建操作。如果你已经有现有的方法来执行需要的任务，就可以使用这个类

2.创建并执行操作

// 这个操作是：调用 self 的 run 方法
NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
// 开始执行任务(同步执行)
[operation start];

NSBlockOperation

1.简介

能够并发地执行一个或多个 block 对象，所有相关的 block 都执行完之后，操作才算完成

2.创建并执行操作

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^(){  
        NSLog(@"执行了一个新的操作，线程：%@", [NSThread currentThread]);
}];
// 开始执行任务(这里还是同步执行)
[operation start];

3.通过 addExecutionBlock 方法添加 block 操作

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^(){  
    NSLog(@"执行第1次操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
    NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
    NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
    NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

// 开始执行任务
[operation start];

打印信息如下：

2013-02-02 21:38:46.102 thread[4602:c07] 又执行了1个新的操作，线程：<NSThread: 0x7121d50>{name = (null), num = 1}
2013-02-02 21:38:46.102 thread[4602:3f03] 又执行了1个新的操作，线程：<NSThread: 0x742e1d0>{name = (null), num = 5}
2013-02-02 21:38:46.102 thread[4602:1b03] 执行第1次操作，线程：<NSThread: 0x742de50>{name = (null), num = 3}
2013-02-02 21:38:46.102 thread[4602:1303] 又执行了1个新的操作，线程：<NSThread: 0x7157bf0>{name = (null), num = 4}

可以看出，这 4 个 block 是并发执行的，也就是在不同线程中执行的，num 属性可以看成是线程的 id。

自定义NSOperation

1.简介

如果 NSInvocationOperation 和 NSBlockOperation 对象不能满足需求，你可以直接继承 NSOperation，并添加任何你想要的行为。继承所需的工作量主要取决于你要实现非并发还是并发的 NSOperation。定义非并发的 NSOperation 要简单许多，只需要重载 -(void)main 这个方法，在这个方法里面执行主任务，并正确地响应取消事件；对于并发 NSOperation，你必须重写 NSOperation 的多个基本方法进行实现(这里暂时先介绍非并发的 NSOperation)。

2.非并发的 NSOperation

比如叫做 DownloadOperation，用来下载图片

1> 继承 NSOperation，重写 main 方法，执行主任务

DownloadOperation.h

#import <Foundation/Foundation.h>
@protocol DownloadOperationDelegate;

@interface DownloadOperation : NSOperation
// 图片的url路径
@property (nonatomic, copy) NSString *imageUrl;
// 代理
@property (nonatomic, retain) id<DownloadOperationDelegate> delegate;

- (id)initWithUrl:(NSString *)url delegate:(id<DownloadOperationDelegate>)delegate;
@end

// 图片下载的协议
@protocol DownloadOperationDelegate <NSObject>
- (void)downloadFinishWithImage:(UIImage *)image;
@end

DownloadOperation.m

#import "DownloadOperation.h"

@implementation DownloadOperation
@synthesize delegate = _delegate;
@synthesize imageUrl = _imageUrl;

// 初始化
- (id)initWithUrl:(NSString *)url delegate:(id<DownloadOperationDelegate>)delegate {
    if (self = [super init]) {
        self.imageUrl = url;
        self.delegate = delegate;
    }
    return self;
}
// 释放内存  
- (void)dealloc {
    [super dealloc];
    [_delegate release];
    [_imageUrl release];
}  

// 执行主任务
- (void)main {
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池
    @autoreleasepool {
        // ....
    }
}
@end

2> 正确响应取消事件

operation 开始执行之后，会一直执行任务直到完成，或者显式地取消操作。取消可能发生在任何时候，甚至在 operation 执行之前。尽管 NSOperation 提供了一个方法，让应用取消一个操作，但是识别出取消事件则是我们自己的事情。如果 operation 直接终止，可能无法回收所有已分配的内存或资源。因此 operation 对象需要检测取消事件，并优雅地退出执行。

NSOperation 对象需要定期地调用 isCancelled 方法检测操作是否已经被取消，如果返回 YES （表示已取消），则立即退出执行。不管是自定义 NSOperation 子类,还是使用系统提供的两个具体子类，都需要支持取消。isCancelled 方法本身非常轻量，可以频繁地调用而不产生大的性能损失。

以下地方可能需要调用isCancelled:

在执行任何实际的工作之前
在循环的每次迭代过程中,如果每个迭代相对较长可能需要调用多次
代码中相对比较容易中止操作的任何地方

DownloadOperation 的 main 方法实现如下

- (void)main {
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池
    @autoreleasepool {
        if (self.isCancelled) return;
        
        // 获取图片数据
        NSURL *url = [NSURL URLWithString:self.imageUrl];
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        
        if (self.isCancelled) {
            url = nil;
            imageData = nil;
            return;
        }
        
        // 初始化图片
        UIImage *image = [UIImage imageWithData:imageData];
        
        if (self.isCancelled) {
            image = nil;
            return;
        }
        
        if ([self.delegate respondsToSelector:@selector(downloadFinishWithImage:)]) {
            // 把图片数据传回到主线程
            [(NSObject *)self.delegate performSelectorOnMainThread:@selector(downloadFinishWithImage:) withObject:image waitUntilDone:NO];
        }
    }
}

GCD

全名是 Grand Central Dispatch，而不是某执政部门，直译成中文是 雄壮的中央调度机制，光听名字就知道这货是个高级玩意儿，不过我水平也有限，有没有提及到的地方，还希望多多交流。

GCD 的基本思想是就将操作放在队列中去执行
操作使用 Block 定义
队列负责调度任务执行所在的线程以及具体的执行时间
队列的特点是先进先出（FIFO）的，新添加至对列的操作都会排在队尾
GCD 的函数都是以 dispatch 开头的

自定义队列

通常是 create 一个 dispatch_queue_t 队列，然后把任务放到队列中，队列分为 dispatch_async （异步队列）和 dispatch_sync （同步队列）。

串行队列

- (void)gcdDemo1 {
    
    // 串行队列
    dispatch_queue_t q = dispatch_queue_create("com.pupboss.gcddemo1", DISPATCH_QUEUE_SERIAL);
    
    // 串行行队列的同步任务，同样会在主线程上运行
    for (int i = 0; i < 5; ++i) {
        // 同步任务顺序执行
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 5; ++i) {
        // 异步任务，并发执行，但是如果在串行队列中，仍然会依次顺序执行
        dispatch_async(q, ^{
            // [NSThread currentThread] 可以在开发中，跟踪当前线程
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

2015-05-23 22:03:17.990 Multi-Thread-Test[4502:211585] <NSThread: 0x7feeb3f289d0>{number = 1, name = main} 0
2015-05-23 22:03:17.990 Multi-Thread-Test[4502:211585] <NSThread: 0x7feeb3f289d0>{number = 1, name = main} 1
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211585] <NSThread: 0x7feeb3f289d0>{number = 1, name = main} 2
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211585] <NSThread: 0x7feeb3f289d0>{number = 1, name = main} 3
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211585] <NSThread: 0x7feeb3f289d0>{number = 1, name = main} 4
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211685] <NSThread: 0x7feeb506dc70>{number = 2, name = (null)} 0
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211685] <NSThread: 0x7feeb506dc70>{number = 2, name = (null)} 1
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211685] <NSThread: 0x7feeb506dc70>{number = 2, name = (null)} 2
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211685] <NSThread: 0x7feeb506dc70>{number = 2, name = (null)} 3
2015-05-23 22:03:17.991 Multi-Thread-Test[4502:211685] <NSThread: 0x7feeb506dc70>{number = 2, name = (null)} 4

并行队列

这个比较有意思了，看下面这种情况

- (void)gcdDemo2 {
    // 并行队列，执行顺序不确定，线程个数不确定
    dispatch_queue_t q = dispatch_queue_create("com.pupboss.gcddemo2", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i < 5; ++i) {
        // 异步任务
        dispatch_async(q, ^{
            // [NSThread currentThread] 可以在开发中，跟踪当前线程
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 5; ++i) {
        // 同步任务顺序执行
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

执行结果是下面的，非常混乱，是吧，但是

2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212722] <NSThread: 0x7f98e9600000>{number = 5, name = (null)} 3
2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212715] <NSThread: 0x7f98e9979e90>{number = 2, name = (null)} 0
2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212664] <NSThread: 0x7f98e9428a30>{number = 1, name = main} 0
2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212714] <NSThread: 0x7f98e9a00a70>{number = 4, name = (null)} 1
2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212716] <NSThread: 0x7f98e98301d0>{number = 3, name = (null)} 2
2015-05-23 22:04:03.804 Multi-Thread-Test[4527:212723] <NSThread: 0x7f98e9a003b0>{number = 6, name = (null)} 4
2015-05-23 22:04:03.805 Multi-Thread-Test[4527:212664] <NSThread: 0x7f98e9428a30>{number = 1, name = main} 1
2015-05-23 22:04:03.805 Multi-Thread-Test[4527:212664] <NSThread: 0x7f98e9428a30>{number = 1, name = main} 2
2015-05-23 22:04:03.805 Multi-Thread-Test[4527:212664] <NSThread: 0x7f98e9428a30>{number = 1, name = main} 3
2015-05-23 22:04:03.805 Multi-Thread-Test[4527:212664] <NSThread: 0x7f98e9428a30>{number = 1, name = main} 4

如果把两个任务换换位置，变成这样

for (int i = 0; i < 5; ++i) {
    // 同步任务顺序执行
    dispatch_sync(q, ^{
        NSLog(@"%@ %d", [NSThread currentThread], i);
    });
}

for (int i = 0; i < 5; ++i) {
    // 异步任务
    dispatch_async(q, ^{
        // [NSThread currentThread] 可以在开发中，跟踪当前线程
        // num = 1，表示主线程
        // num = 2，表示第2个子线程。。。
        NSLog(@"%@ %d", [NSThread currentThread], i);
    });
}

运行结果就变了

2015-05-23 22:04:58.874 Multi-Thread-Test[4555:214018] <NSThread: 0x7fc8d3c28bd0>{number = 1, name = main} 0
2015-05-23 22:04:58.876 Multi-Thread-Test[4555:214018] <NSThread: 0x7fc8d3c28bd0>{number = 1, name = main} 1
2015-05-23 22:04:58.876 Multi-Thread-Test[4555:214018] <NSThread: 0x7fc8d3c28bd0>{number = 1, name = main} 2
2015-05-23 22:04:58.876 Multi-Thread-Test[4555:214018] <NSThread: 0x7fc8d3c28bd0>{number = 1, name = main} 3
2015-05-23 22:04:58.876 Multi-Thread-Test[4555:214018] <NSThread: 0x7fc8d3c28bd0>{number = 1, name = main} 4
2015-05-23 22:04:58.880 Multi-Thread-Test[4555:214043] <NSThread: 0x7fc8d3e00ae0>{number = 2, name = (null)} 0
2015-05-23 22:04:58.881 Multi-Thread-Test[4555:214043] <NSThread: 0x7fc8d3e00ae0>{number = 2, name = (null)} 1
2015-05-23 22:04:58.881 Multi-Thread-Test[4555:214044] <NSThread: 0x7fc8d3e03280>{number = 3, name = (null)} 2
2015-05-23 22:04:58.881 Multi-Thread-Test[4555:214043] <NSThread: 0x7fc8d3e00ae0>{number = 2, name = (null)} 4
2015-05-23 22:04:58.881 Multi-Thread-Test[4555:214046] <NSThread: 0x7fc8d3f0adb0>{number = 4, name = (null)} 3

说明并行队列中的同步任务，还是在主线程上，并且执行完了之后才会往下走

全局队列

苹果为了方便多线程的设计，提供一个全局队列，供所有的APP共同使用

dispatch_queue_t  queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

两个参数，一个是优先级，一个是 0，现在只能写 0，因为苹果没想好这个参数怎么开放给开发者。

全局队列用起来跟并行队列是差不多的，所以就不上代码了

主线程队列

每一个应用程序都只有一个主线程，有些操作，需要放到主线程队列来完成，比如数据下载完，刷新界面，等等

主线程队列千万不要使用同步任务，会发生阻塞！

- (void)gcdDemo4 {
    
    dispatch_queue_t q = dispatch_get_main_queue();
    
    // 异步任务，在主线程上运行，同时是保持队形的
    for (int i = 0; i < 5; ++i) {
        dispatch_async(q, ^{
            NSLog(@"%@ - %d", [NSThread currentThread], i);
        });
    }
}

运行结果

2015-05-23 22:34:17.663 Multi-Thread-Test[4800:243581] <NSThread: 0x7fbffc023060>{number = 1, name = main} - 0
2015-05-23 22:34:17.664 Multi-Thread-Test[4800:243581] <NSThread: 0x7fbffc023060>{number = 1, name = main} - 1
2015-05-23 22:34:17.664 Multi-Thread-Test[4800:243581] <NSThread: 0x7fbffc023060>{number = 1, name = main} - 2
2015-05-23 22:34:17.664 Multi-Thread-Test[4800:243581] <NSThread: 0x7fbffc023060>{number = 1, name = main} - 3
2015-05-23 22:34:17.664 Multi-Thread-Test[4800:243581] <NSThread: 0x7fbffc023060>{number = 1, name = main} - 4

批量下载图片

for (int i = 1; i < 100; ++i) {
    
    dispatch_sync(q, ^{
        
        NSLog(@"%@ %d", [NSThread currentThread], i);
        NSString *imageName = [NSString stringWithFormat:@"%d.jpg", i];
        
        NSString *url = [NSString stringWithFormat:@"http://xxxxy/%@", imageName];
        
        [LJFileTool writeImageToFileName:imageName withImgURL:url];
    });
}

这么写没什么好处 = =，也就是不阻塞主线程，除此之外真没啥了。。。。卧槽，本来想写成异步任务的，结果发现老是有问题，而且速度也一般。

iOS 的推送

NSArray *startArr = [NSArray arrayWithContentsOfFile:@"/xxxxx/test.plist"];
    
    dispatch_queue_t q = dispatch_queue_create("com.pupboss.pusher", DISPATCH_QUEUE_SERIAL);
    
    for (int i = 0; i < startArr.count; ++i) {
        dispatch_async(q, ^{
            
            NSLog(@"%@ %d", [NSThread currentThread], i);
            
            NSLog(@"%@", startArr[i]);
            
            [self sendMsg:startArr[i]];
        });
    }

Recommended for you

iOS

一份非常详尽的 Objective-C 到 Swift 的迁移指南

7 years ago • 12 min read

iOS

近期重构工作的一点收获

7 years ago • 9 min read

iOS

自己动手实现一个简单的 UITableView

8 years ago • 5 min read

关于 Clash 科学上网的最佳实践

TL-R5408M 拆机 / 芯片设计评测

关于 TP-LINK XDR6088 那些有的没的

记一次 DDoS (刷流量) 攻击来源地梅州市五华县

iOS Objective-C 基础 (三) - 多线程

NSThread

NSOperation

NSOperation

NSInvocationOperation

NSBlockOperation

自定义NSOperation

GCD

串行队列

并行队列

全局队列

主线程队列

批量下载图片

iOS 的推送

Tags

Jie Li

Recommended for you

一份非常详尽的 Objective-C 到 Swift 的迁移指南

近期重构工作的一点收获

自己动手实现一个简单的 UITableView

关于 Clash 科学上网的最佳实践

TL-R5408M 拆机 / 芯片设计评测

关于 TP-LINK XDR6088 那些有的没的

记一次 DDoS (刷流量) 攻击 来源地梅州市 五华县

NSThread

NSOperation

NSOperation

NSInvocationOperation

NSBlockOperation

自定义NSOperation

GCD

串行队列

并行队列

全局队列

主线程队列

批量下载图片

iOS 的推送

Tags

Jie Li

Recommended for you

一份非常详尽的 Objective-C 到 Swift 的迁移指南

近期重构工作的一点收获

自己动手实现一个简单的 UITableView

记一次 DDoS (刷流量) 攻击来源地梅州市五华县