 
         dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
             self.fetchSourceObjects() { [weak self] sourceObjects, hasNext in
-                guard let weakSelf = self else {
-                    return
-                }
 
                 // Prevent data mismatch when cleared existing data while fetching new data
                 if oldDataCount == self?.sourceObjects.count {
                     self?.sourceObjects += sourceObjects
                 }
 
-                dispatch_async(dispatch_get_main_queue()) {
-                    UIView.setAnimationsEnabled(false)
-                    if let mainSection = weakSelf.sectionTypes.indexOf(.Main) {
-                        let newDataCount = weakSelf.sourceObjects.count
-                        let currentDataCount = weakSelf.tableView.numberOfRowsInSection(mainSection)
-                        if currentDataCount < newDataCount {
-                            self?.tableView.insertRowsAtIndexPaths(
-                                Array(currentDataCount..<newDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
-                                withRowAnimation: .None)
-                        } else {
-                            self?.tableView.deleteRowsAtIndexPaths(
-                                Array(newDataCount..<currentDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
-                                withRowAnimation: .None)
-                        }
-
-                        if reload {
-                            self?.tableView.reloadRowsAtIndexPaths(
-                                Array(0..<newDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
-                                withRowAnimation: .None)
+                if self?.isScrolling == true {
+                    if self?.pendingProcess == nil {
+                        self?.pendingProcess = {
+                            self?.updateTable(reload: reload, hasNext: hasNext)
                         }
                     }
-                    UIView.setAnimationsEnabled(true)
-
-                    if !hasNext {
-                        self?.updateFooter(false)
-                    } else {
-                        // To call willDisplayCell delegate to read cells
-                        self?.updateFooter(true)
-                    }
+                } else {
+                    self?.updateTable(reload: reload, hasNext: hasNext)
                 }
 
                 self?.isRequesting = false


    public override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
        didSelectRow?(indexPath.row)
    }

    // MARK: - Public

        }
    }

    private func updateTable(reload reload: Bool, hasNext: Bool) {
        dispatch_async(dispatch_get_main_queue()) {
            UIView.setAnimationsEnabled(false)
            if let mainSection = self.sectionTypes.indexOf(.Main) {
                let newDataCount = self.sourceObjects.count
                let currentDataCount = self.tableView.numberOfRowsInSection(mainSection)
                if currentDataCount < newDataCount {
                    self.tableView.insertRowsAtIndexPaths(
                        Array(currentDataCount..<newDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
                        withRowAnimation: .None)
                } else {
                    self.tableView.deleteRowsAtIndexPaths(
                        Array(newDataCount..<currentDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
                        withRowAnimation: .None)
                }

                if reload {
                    self.tableView.reloadRowsAtIndexPaths(
                        Array(0..<newDataCount).map { NSIndexPath(forRow: $0, inSection: mainSection) },
                        withRowAnimation: .None)
                }
            }
            UIView.setAnimationsEnabled(true)

            if !hasNext {
                self.updateFooter(false)
            } else {
                // To call willDisplayCell delegate to read cells
                self.updateFooter(true)
            }
        }
    }

    private func updateFooter(show: Bool) {
        guard pendingProcess == nil else {
            return
        }

        guard let footerSection = sectionTypes.indexOf(.Footer) else {
            return
        }
