从资产目录中加载图像到主线程之外？

Question

I'm trying to load an image from an asset catalog into a UIImage off of the main thread, but can't seem to find any way to do it. If the image was not in an asset catalog I would use pathForResource and imageWithContentsOfFile:

NSString *path = [[NSBundle mainBundle] pathForResource:icon ofType:nil];
if(path) {
  image = [UIImage imageWithContentsOfFile:path];
}

But pathForResource: does not work for images in asset catalogs. Is there any way to do this without having to go to the main thread to load the image? Im guessing the answer is no.

What won't work:

• Manually creating the path for the image based on the main bundle path. I have images in multiple asset catalogs, and asset catalogs can be compiled in a binary form.
• [UIImage imageNamed:] is not thread safe, and can not be used off the main thread. The docs have said it's not thread safe for at least the last several major releases of iOS, and starting in iOS 8 it really does crash when used off the main thread.

What i'm doing now:

dispatch_sync(dispatch_get_main_queue(), ^{
  image = [UIImage imageNamed:icon];
});

Answer 1

It seems like you've answered your own question: use dispatch_sync to invoke imageNamed: on the main thread.

The Asset Catalog format is opaque; your only interface to it is imageNamed: . Its documentation says:

This method looks in the system caches for an image object with the specified name and returns that object if it exists. If a matching image object is not already in the cache, this method locates and loads the image data from disk or asset catalog, and then returns the resulting object. You can not assume that this method is thread safe.

There is a trade-off here between speed and safety; Apple chose speed. To allow imageNamed: to be called from any thread would require either (A) synchronizing access to the system caches, adding overhead or (B) not using a cache at all.

Since imageNamed: is most often used to support loading of images for the UI, and the UI work is already tied to the main thread, it makes sense to optimize around that case, and push the work of synchronization onto callers who are not on the main thread.

So, using dispatch_sync is the way to go. If you are worried about thread contention, you could easily cache the images so that the background thread only waits on the main thread when it absolutely has to. I wouldn't do that unless you have determined via profiling that it would make a noticeable difference in performance, though.

Note that if Apple had decided to allow imageNamed: to be called on a background thread, they would have had to synchronize access to their caches, making the performance not that much different than adding dispatch_sync to your own code.

If your requirements are:

• you must absolutely, positively, never touch the main thread; and
• you must absolutely, positively, include your images in an Asset Catalog;

then the only alternative that I can see is reverse engineering the Asset Catalog file format and reading from the disk directly. Your app may break if the file format changes, but fortunately that would only happen at build time, so future OS updates shouldn't break your app.

Answer 2

If you're loading an image saved in the project you'd use [UIImage imageNamed: @"image1"]; no extensions like @"image1.png"

UIImage *image = [UIImage imageNamed: @"<#image name#>"];

Hope this helps :)