How to run tasks off the main actor with Swift Concurrency

Question

I am using a Task block to fetch images from disk to be displayed in a UIImageView.

I noticed that as I scroll the collection view, there's noticeable lag caused by the getArtwork method meaning it is blocking the main actor.

Marking it as "nonisolated" fixes the issue which if I understand correctly, means the method is not isolated to the current actor context but most examples I have seen uses the keyword in actors NOT classes thus I am wondering if it is even appropriate in a class?

class ListViewCell: UICollectionViewListCell {
    private lazy var thumbnailImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFit
        imageView.layer.cornerRadius = 5
        imageView.clipsToBounds = true
        imageView.translatesAutoresizingMaskIntoConstraints = false
        return imageView
    }()
    
    private lazy var placeholderImageView: UIImageView = {
        let cfg = UIImage.SymbolConfiguration(scale: .small)
        let image = UIImage(systemName: "music.note", withConfiguration: cfg)
        let imageView = UIImageView(image: image)
        imageView.contentMode = .scaleAspectFit
        imageView.tintColor = .tertiaryLabel
        imageView.translatesAutoresizingMaskIntoConstraints = false
        return imageView
    }()
    
    private lazy var nameLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.lineBreakMode = .byTruncatingTail
        return label
    }()
    
    private lazy var artistLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.font = .preferredFont(forTextStyle: .subheadline)
        label.textColor = .secondaryLabel
        label.lineBreakMode = .byTruncatingTail
        return label
    }()
    
    var audioFile: AudioFile?
    private var thumbnailTask: Task<Void, Never>?
    
    override init(frame: CGRect) {
        super.init(frame: frame)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func prepareForReuse() {
        super.prepareForReuse()
        thumbnailTask?.cancel()
        thumbnailImageView.image = nil
        thumbnailImageView.backgroundColor = nil
    }
    
    func configure(with audioFile: AudioFile) {
        self.audioFile = audioFile
        
        if let artwork = audioFile.artwork {
            thumbnailTask = Task { [weak self] in
                var thumbnail: UIImage?
                if let cachedImage = self?.imageCache.object(forKey: artwork as NSString) {
                    thumbnail = cachedImage
                } else {
                    thumbnail = await self?.getArtwork(for: artwork)
                }
                
                await MainActor.run { [weak self] in
                    // Check if the cell's audioFile is still the same
                    if audioFile == self?.audioFile {
                        self?.thumbnailImageView.image = thumbnail
                    }
                }
            }
        } else {
            thumbnailImageView.addSubview(placeholderImageView)

            NSLayoutConstraint.activate([
                placeholderImageView.widthAnchor.constraint(equalToConstant: 30),
                placeholderImageView.heightAnchor.constraint(equalToConstant: 30),
                placeholderImageView.centerXAnchor.constraint(equalTo: thumbnailImageView.centerXAnchor),
                placeholderImageView.centerYAnchor.constraint(equalTo: thumbnailImageView.centerYAnchor)
            ])
            
            thumbnailImageView.bringSubviewToFront(placeholderImageView)
            thumbnailImageView.backgroundColor = .quaternarySystemFill
        }
    }
    
    private var imageCache = NSCache<NSString, UIImage>()

    nonisolated func getArtwork(for name: String) async -> UIImage? {
        let url = FileManager.artworksFolderURL.appendingPathComponent(name)
        
        do {
            let data = try Data(contentsOf: url)
            if let image = UIImage(data: data) {
                let targetSize = CGSize(width: 50, height: 50)
                let imageSize = image.size
                let widthRatio = targetSize.width / imageSize.width
                let heightRatio = targetSize.height / imageSize.height
                let scaleFactor = min(widthRatio, heightRatio)
                
                let scaledImageSize = CGSize(width: imageSize.width * scaleFactor, height: imageSize.height * scaleFactor)
                let renderer = UIGraphicsImageRenderer(size: targetSize)
                
                let centeredImage = renderer.image { context in
                    let origin = CGPoint(
                        x: (targetSize.width - scaledImageSize.width) / 2,
                        y: (targetSize.height - scaledImageSize.height) / 2
                    )
                    context.cgContext.addPath(UIBezierPath(roundedRect: CGRect(origin: origin, size: scaledImageSize), cornerRadius: 5).cgPath)
                    context.cgContext.clip()
                    image.draw(in: CGRect(origin: origin, size: scaledImageSize))
                }
                
                await MainActor.run {
                    imageCache.setObject(centeredImage, forKey: name as NSString)
                }
                
                return centeredImage
            }
        } catch {
            print("Error loading image data: \(error)")
            return nil
        }
        
        return nil
    }
}

The func getArtwork(for:) seems to be called only from within a Task which is created in the method configure(with:) which is isolated, and thus the Task's closure and thus getArtwork(for:) should run on this actor as well, i.e. on the main thread. I fail to see why adding nonisolated to this function should fix it, unless you call it directly from elsewhere. IMHO, the problems you see coming from the weaknesses in your design. So, you should tackle this first ;) — CouchDeveloper
– CouchDeveloper, Commented Aug 14, 2024 at 16:15
@CouchDeveloper – As of Swift 5.7, a nonisolated async function explicitly runs on a generic executor, i.e. off the main actor in this case. See SE-0338. (And, as an aside, Swift 6 gives even more control, via SE-0417.) — Rob
– Rob, Commented Aug 14, 2024 at 16:31
@Rob Ah, thanks Rob! I still need to know the reasoning for this, will read it. ;) — CouchDeveloper
– CouchDeveloper, Commented Aug 14, 2024 at 16:34
Making the cache a static property of the class means all cells will use the same cache? — User95797654974
– User95797654974, Commented Aug 14, 2024 at 17:31
Yes, with static, they will all use a single, shared cache. — Rob
– Rob, Commented Aug 14, 2024 at 17:57

Sweeper · Accepted Answer · 2024-08-14 01:27:02Z

2

thus I am wondering if it is even appropriate in a class?

Yes, it is appropriate in this case. Your class ListViewCell inherits from a MainActor-isolated class UICollectionViewListCell, so it and its members are also MainActor-isolated by default.

This is semantically not that different from the members declared in an actor type. Instead of being isolated to the enclosing actor type, the members in ListViewCell are isolated to the global actor that is MainActor. To opt out of this isolation is exactly the purpose of nonisolated.

From the global actors SE proposal:

It is common for entire types (and even class hierarchies) to predominantly require execution on the main thread, and for asynchronous work to be a special case. In such cases, the type itself can be annotated with a global actor, and all of the methods, properties, and subscripts will implicitly be isolated to that global actor. Any members of the type that do not want to be part of the global actor can opt out, e.g., using the nonisolated modifier.

That said, it is also not a good idea to block other threads for long periods of time. The fundamental assumption in Swift Concurrency is that threads will always make progress. I see that you are doing:

let data = try Data(contentsOf: url)

which is blocking. If this is indeed what causes the lag, consider using URLSession instead:

let (data, _) = try await URLSession.shared.data(from: url)

If you need to do other CPU intensive work, you should do it using GCD, and port it to Swift Concurrency using withCheckedThrowingContinuation and friends.

answered Aug 14, 2024 at 1:27

Sweeper

292k23 gold badges260 silver badges438 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

User95797654974 Over a year ago

The url is a local url to a file on disk. Would I still need to use URLSession for it?

Sweeper Over a year ago

@User95797654974 If the file is large, yes you should still use URLSession.

Collectives™ on Stack Overflow

How to run tasks off the main actor with Swift Concurrency

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related