UICollectionView reloadItems触发多cell的didSet致点赞按钮响应延迟

Hey there! Let’s break down your problem step by step—this is super common with UICollectionView cell reuse, so you’re absolutely on the right track suspecting that’s part of the issue.

Why are multiple cells' didSet triggers firing? #

Yes, this is directly tied to cell reuse and how you’re updating your data source/refreshing the collection view. Here’s what’s likely happening:

1. Global refresh instead of targeted updates: If you’re calling collectionView.reloadData() after tapping the like button, this forces every visible cell to reconfigure. Each cell’s post property gets reset, triggering didSet for all of them—even the ones you didn’t tap.
2. Incorrect data source updates: If your Post model is a value type (like a struct), updating one post’s isLiked property by reassigning the entire array (instead of just the specific index) can cause unintended cascading updates. Or if you’re re-fetching the full list of posts after a like, every visible cell will get reconfigured with their (unchanged) post data.

How to fix the lag and get instant like button updates? #

Let’s tackle both the lag and the unwanted didSet triggers with these fixes:

1. Stop triggering didSet for unrelated cells

• Only refresh the target cell: After updating your data source for the liked post, use reloadItems(at: [indexPath]) instead of reloadData(). This tells the collection view to only reconfigure the specific cell you tapped, so only that cell’s didSet will fire.
  Example:

  // When handling the like tap
  guard let indexPath = collectionView.indexPath(for: tappedCell) else { return }
  
  // Update your data source (adjust based on struct vs class)
  if var post = posts[indexPath.row] { // For structs
      post.isLiked = !post.isLiked
      posts[indexPath.row] = post
  } else { // For classes
      posts[indexPath.row].isLiked = !posts[indexPath.row].isLiked
  }
  
  // Refresh ONLY the target cell
  collectionView.reloadItems(at: [indexPath])
  

• Clean up cell reuse state: In cellForItemAt, reset the cell’s state before assigning the post to avoid leftover UI from reused cells. For example:

  func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
      let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "PostCell", for: indexPath) as! PostCell
      
      // Reset state first to prevent reuse artifacts
      cell.likeButton.tintColor = .gray
      
      // Assign the post
      cell.post = posts[indexPath.row]
      return cell
  }
  

2. Eliminate lag for instant like button updates

The 3-second delay between print("BEGIN") and print("END") means your main thread is being blocked. Fix this with:

• Update UI first, handle async work later: Don’t wait for a network request to finish before updating the button color. Toggle the UI immediately, then handle the network call in the background. If the request fails, revert the UI state.
  Example:

  @IBAction func likeButtonTapped(_ sender: UIButton) {
      guard let cell = sender.superview?.superview as? PostCell,
            let indexPath = collectionView.indexPath(for: cell) else { return }
      
      // Instantly toggle the button color
      let newColor = sender.tintColor == .red ? .gray : .red
      sender.tintColor = newColor
      
      // Handle network work in the background (never block the main thread!)
      DispatchQueue.global(qos: .userInitiated).async { [weak self] in
          guard let self = self else { return }
          let success = self.toggleLike(for: self.posts[indexPath.row])
          
          // Update data source and fix UI if needed, back on main thread
          DispatchQueue.main.async {
              if success {
                  // Sync your data source with the new state
                  var post = self.posts[indexPath.row]
                  post.isLiked = !post.isLiked
                  self.posts[indexPath.row] = post
              } else {
                  // Revert UI if request failed
                  sender.tintColor = newColor == .red ? .gray : .red
              }
          }
      }
  }
  

• Simplify didSet logic: Make sure your post property’s didSet only does minimal UI work—no heavy parsing, file I/O, or network calls here. If you need to load data (like images), do it asynchronously off the main thread.
  Example clean didSet:

  var post: Post? {
      didSet {
          guard let post = post else { return }
          print("BEGIN")
          // Only update UI elements directly
          likeButton.tintColor = post.isLiked ? .red : .gray
          titleLabel.text = post.title
          print("END")
      }
  }
  

• Optimize infinite scrolling: When loading more posts, do all network requests and data parsing in the background. Only update the collection view on the main thread once the data is ready, and avoid loading too many posts at once to prevent main thread congestion.

内容的提问来源于stack exchange，提问作者Kirill