問：runloop如何優化tableView

回答：
把任務以block塊的方式封裝起來，存放到任務陣列中，若任務陣列中的任務數超出最大任務數，則刪除靠前的任務，註冊runloop的觀察者，在回撥方法裡，執行任務陣列中的一個任務，並刪除執行後的任務。新增timer事件，防止runloop進入休眠狀態。

回答解析：
為了解決tableView的卡頓現象，可以runloop一次處理一個任務，

根據當前的runloop和觀察者的上下文，通過CFRunLoopObserverCreate函式，定義一個觀察runloop即將進入休眠狀態（BeforeWaiting）時的觀察者，新增runloop在common

在觀察者回調函式中，根據觀察者上下文執行當前物件任務陣列中的第一個任務，任務執行後從陣列中移除，

在繪製cell的方法（即cellForRow）中，呼叫新增任務的方法，在這個方法的內部，將用block程式碼塊包裝的任務新增到陣列中，若超出最大任務數，則刪除之前的任務，便於觀察者回調函式分開執行任務，減少對系統資源的消耗，

最後新增timer或source0 事件，使runloop不進入休眠狀態。

卡頓原因：

tableView載入過多的高清大圖，拖動tableView時，runloop不僅需要處理拖動事件，還要處理圖片渲染，從而造成卡頓。

需求：
從網路載入高清大圖到UITableViewCell上，而且每個Cell上面載入多張圖片，當cell數量過多的時候，我們需要保持流暢度和載入速度。

通過runloop優化TableView

整體來講：在cellforRow方法裡，以block程式碼塊的方式把任務儲存到陣列中，註冊runloop的觀察者，完成回撥方法，執行block任務，從陣列中刪除執行後的任務，保持runloop不休眠。
步驟：

1、獲取當前主執行緒的 runloop

  //獲取當前RunLoop
//swift實現
  let runLoop: CFRunLoop = CFRunLoopGetCurrent()
複製程式碼

  //獲取當前RunLoop
// oc實現
 CFRunLoopRef runloop = CFRunLoopGetCurrent();
複製程式碼

2、建立觀察者 CFRunLoopObserverRef ， 來監聽 runloop

• 建立觀察者用到的核心函式就是
  CFRunLoopObserverCreate：

// allocator：該引數為物件記憶體分配器，一般使用預設的分配器kCFAllocatorDefault。
// activities：要監聽runloop的狀態
/*
typedef CF_OPTIONS(CFOptionFlags,CFRunLoopActivity) {
        kCFRunLoopEntry         = (1UL << 0),// 即將進入Loop
        kCFRunLoopBeforeTimers  = (1UL << 1),// 即將處理 Timer
        kCFRunLoopBeforeSources = (1UL << 2),// 即將處理 Source
        kCFRunLoopBeforeWaiting = (1UL << 5),// 即將進入休眠
        kCFRunLoopAfterWaiting  = (1UL << 6),// 剛從休眠中喚醒
        kCFRunLoopExit          = (1UL << 7),// 即將退出Loop
        kCFRunLoopAllActivities = 0x0FFFFFFFU // 所有事件
    };
*/
// repeats：是否重複監聽
//   order：觀察者優先順序，當Run Loop中有多個觀察者監聽同一個執行狀態時，根據該優先順序判斷，0為最高優先級別。
// callout：觀察者的回撥函式，在Core Foundation框架中用CFRunLoopObserverCallBack重定義了回撥函式的閉包。
// context：觀察者的上下文。
CF_EXPORT CFRunLoopObserverRef CFRunLoopObserverCreate(CFAllocatorRef allocator,CFOptionFlags activities,Boolean repeats,CFIndex order,CFRunLoopObserverCallBack callout,CFRunLoopObserverContext *context);
複製程式碼

2-1、建立觀察者

//  1.定義上下文
    //runloop觀察者上下文， 為下面建立觀察者準備，只有建立上下文才能在回調了拿到self物件，才能進行我們的邏輯操作. 這是一個結構體。

    /**

     typedef struct {

     CFIndex version;

     void * info;

     const void *(*retain)(const void *info);

     void (*release)(const void *info);

     CFStringRef (*copyDescription)(const void *info);

     } CFRunLoopObserverContext;

     **/
CFRunLoopObserverContext context = {
    0,(__bridge void *)(self),&CFRetain,&CFRelease,NULL
};
//  2.定義觀察者
static CFRunLoopObserverRef defaultModeObserver;
//  3.建立觀察者
defaultModeObserver = CFRunLoopObserverCreate(kCFAllocatorDefault,kCFRunLoopBeforeWaiting,YES,&callBack,&context);
//  4.給當前runloop新增觀察者
//  kCFRunLoopDefaultMode: App的預設 Mode，通常主執行緒是在這個 Mode 下執行的。
//  UITrackingRunLoopMode: 介面跟蹤 Mode，用於 ScrollView 追蹤觸控滑動，保證介面滑動時不受其他 Mode 影響。
//  UIInitializationRunLoopMode: 在剛啟動 App 時進入的第一個 Mode，啟動完成後就不再使用。
//  GSEventReceiveRunLoopMode: 接受系統事件的內部 Mode，通常用不到。
//  kCFRunLoopCommonModes: 這是一個佔位的 Mode，沒有實際作用。
CFRunLoopAddObserver(runloop,defaultModeObserver,kCFRunLoopCommonModes);
//  5.記憶體管理
CFRelease(defaultModeObserver);
複製程式碼

   ///新增runloop的監聽
    fileprivate func addRunloopObserver() {
        //獲取當前RunLoop
        let runLoop: CFRunLoop = CFRunLoopGetCurrent()
        //定義一個上下文
        var context: CFRunLoopObserverContext = CFRunLoopObserverContext(version: 0,info: unsafeBitCast(self,to: UnsafeMutableRawPointer.self),retain: nil,release: nil,copyDescription: nil)
        //定義一個觀察者
        if   let observer = CFRunLoopObserverCreate(kCFAllocatorDefault,CFRunLoopActivity.beforeWaiting.rawValue,true,self.observerCallbackFunc(),&context){
            //添加當前RunLoop的觀察者
            CFRunLoopAddObserver(runLoop,observer,.commonModes);
        }
    }
複製程式碼

2-2、實現 callBack 函式，只要檢測到對應的runloop狀態，該函式就會得到響應。

//回撥函式
static void callBack(CFRunLoopObserverRef observer,CFRunLoopActivity activity,void *info) {
    
    ViewController *vc = (__bridge ViewController *)info;
    
    //無任務  退出
    if (vc.tasksArr.count == 0) return;
    
    //從陣列中取出任務
    runloopBlock block = [vc.tasksArr firstObject];
    
    //執行任務
    if (block) {
        block();
    }
    
    //執行完任務之後移除任務
    [vc.tasksArr removeObjectAtIndex:0];
    
}
複製程式碼

///回撥函式
    func observerCallbackFunc() -> CFRunLoopObserverCallBack {
        return {(observer,activity,context) -> Void in
            if context == nil {//如果沒有取到  直接返回
                return
            }
            // 崩潰的與原因不在這裡  isFromADGuide 的問題 不應該取反
            //取出上下文 就是當前的vc
            let vc = unsafeBitCast(context,to: XXXFinancialFroductListVC.self)
            //取出任務
            if let unit = vc.tasksArr.first,let indexP = vc.tasksIndexPathArr.first {
                var result = false
                while (result == false && !vc.tasksArr.isEmpty && !vc.tasksIndexPathArr.isEmpty){
                    //執行任務
                    result = unit(indexP);
                    //幹掉第一個任務
                    _ = vc.tasksArr.remove(at: 0)
                    _ = vc.tasksIndexPathArr.remove(at: 0)
                }
            }
        }
複製程式碼

2-3、從上面的函式實現中我們看到了block、arr等物件，下面解析下

//使用 Array 來儲存需要執行的任務
- (NSMutableArray *)tasksArr {
    if (!_tasksArr) {
        _tasksArr = [NSMutableArray array];
    }
    return _tasksArr;
}
// maxTaskCount 來表示最大任務數，優化專案
@property (nonatomic,assign) NSUInteger maxTaskCount;
...
// 當超出最大任務數時，以前的老任務將從陣列中移除
self.maxTaskCount = 50;
複製程式碼

//任務陣列
var tasksArr: [RunloopBlock] = []
//任務對應indexPath陣列
var tasksIndexPathArr: [IndexPath] = []
 //最大任務 10
let maxQueueLength = 10
複製程式碼

使用 block程式碼塊 來包裝一個個將要執行的任務，便於 callBack 函式中分開執行任務，減少同時執行對系統資源的消耗。

//1. 定義一個任務block
typedef void(^runloopBlock)();
//2. 定義一個新增任務的方法，將任務裝在陣列中
- (void)addTasks:(runloopBlock)task {
    //儲存新任務
    [self.tasksArr addObject:task];
    //如果超出最大任務數 丟棄之前的任務
    if (self.tasksArr.count > _maxTaskCount) {
        [self.tasksArr removeObjectAtIndex:0];
    }
}
//3. 將任務新增到程式碼塊中
// 耗時操作放在任務中
[self addTasks:^{
    UIImageView *img1 = [[UIImageView alloc] initWithFrame:CGRectMake(kBorder_W,kBorder_W,width,kCell_H-kBorder_W)];
    img1.image = [UIImage imageNamed:@"Blue Pond.jpg"];
    [cell addSubview:img1];
}];
複製程式碼

//定義blcok
typealias RunloopBlock = ((IndexPath) -> Bool)
private let cellID = "XXXFinancialFroductListVCCell"

   override func tableView(_ tableView: UITableView,cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell: XXXFinancialProductCell = tableView.dequeueReusableCell(withIdentifier: cellID) as! XXXFinancialProductCell
        self.addTask(indexPath) { (indexP) -> Bool in
            cell.kaDunHandler(self.pageManager.dataArr,tableView,indexP)
            return true
        }
        return cell
    }

   //新增新的任務的方法!
    func addTask(_ indexP: IndexPath,unit: @escaping RunloopBlock) {
        self.tasksArr.append(unit)
        self.tasksIndexPathArr.append(indexP)
        //判斷一下 保證沒有來得及顯示的cell不會繪製
        if self.tasksArr.count > self.maxQueueLength {
            _ = self.tasksArr.remove(at: 0)
            _ = self.tasksIndexPathArr.remove(at: 0)
        }
    }

複製程式碼

4、使 runloop 不進入休眠狀態。

runloop 在載入完 cell 時沒有其他事情做了，為了節省資源消耗，就進入了休眠狀態，等待有任務時再次被喚醒。在我們觀察者的 callBack 函式中任務被一個個取出執行，還沒有執行完，runloop 就切換狀態了（休眠了）， callBack 函式不再響應。導致出現上面的情況。

解決方法：

//建立定時器 (保證runloop回撥函式一直在執行)
CADisplayLink *displayLink = [CADisplayLink displayLinkWithTarget:self
                                                         selector:@selector(notDoSomething)];
[displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];

- (void)notDoSomething {
    // 不做事情,就是為了讓 callBack() 函式一直相應
}
複製程式碼

//定時器，保證runloop一直處於迴圈中
@property (nonatomic,weak) NSTimer *timer;

//給runloop一個事件源，讓Runloop不斷的執行執行程式碼塊任務
self.timer = [NSTimer scheduledTimerWithTimeInterval:0.001 target:self selector:@selector(setRunLoop) userInfo:nil repeats:YES];

//此方法主要是利用計時器事件保持runloop處於迴圈中，什麼都不幹，APP效能影響並不大。但cpu增加負擔
-(void)setRunLoop{}複製程式碼

>作為一個開發者，有一個學習的氛圍和一個交流圈子特別重要，這是我的交流群，大家有興趣可以進群裡一起交流學習。點選進群（123）

原文地址：www.jianshu.com/p/4fdbd1c24…