Flutter加載圖片流程之ImageCache源碼分析

這篇文章主要講解了“Flutter加載圖片流程之ImageCache源碼分析”，文中的講解內(nèi)容簡(jiǎn)單清晰，易于學(xué)習(xí)與理解，下面請(qǐng)大家跟著小編的思路慢慢深入，一起來(lái)研究和學(xué)習(xí)“Flutter加載圖片流程之ImageCache源碼分析”吧！

ImageCache

const int _kDefaultSize = 1000;
const int _kDefaultSizeBytes = 100 << 20; // 100 MiB
/// Class for caching images.
///
/// Implements a least-recently-used cache of up to 1000 images, and up to 100
/// MB. The maximum size can be adjusted using [maximumSize] and
/// [maximumSizeBytes].
///
/// The cache also holds a list of 'live' references. An image is considered
/// live if its [ImageStreamCompleter]'s listener count has never dropped to
/// zero after adding at least one listener. The cache uses
/// [ImageStreamCompleter.addOnLastListenerRemovedCallback] to determine when
/// this has happened.
///
/// The [putIfAbsent] method is the main entry-point to the cache API. It
/// returns the previously cached [ImageStreamCompleter] for the given key, if
/// available; if not, it calls the given callback to obtain it first. In either
/// case, the key is moved to the 'most recently used' position.
///
/// A caller can determine whether an image is already in the cache by using
/// [containsKey], which will return true if the image is tracked by the cache
/// in a pending or completed state. More fine grained information is available
/// by using the [statusForKey] method.
///
/// Generally this class is not used directly. The [ImageProvider] class and its
/// subclasses automatically handle the caching of images.
///
/// A shared instance of this cache is retained by [PaintingBinding] and can be
/// obtained via the [imageCache] top-level property in the [painting] library.
///
/// {@tool snippet}
///
/// This sample shows how to supply your own caching logic and replace the
/// global [imageCache] variable.

ImageCache類(lèi)是一個(gè)用于緩存圖像的類(lèi)。它實(shí)現(xiàn)了一個(gè)最近最少使用的緩存，最多緩存1000個(gè)圖像，最大緩存100MB。緩存的最大大小可以使用maximumSize和maximumSizeBytes進(jìn)行調(diào)整。

ImageCache還持有一個(gè)"活"圖像引用的列表。當(dāng)ImageStreamCompleter的監(jiān)聽(tīng)計(jì)數(shù)在添加至少一個(gè)監(jiān)聽(tīng)器后從未降至零時(shí)，圖像被認(rèn)為是"活"的。緩存使用ImageStreamCompleter.addOnLastListenerRemovedCallback方法來(lái)確定這種情況是否發(fā)生。

putIfAbsent方法是緩存API的主要入口點(diǎn)。如果給定鍵的先前緩存中有ImageStreamCompleter可用，則返回該實(shí)例；否則，它將首先調(diào)用給定的回調(diào)函數(shù)來(lái)獲取該實(shí)例。在任何情況下，鍵都會(huì)被移到"最近使用"的位置。

調(diào)用者可以使用containsKey方法確定圖像是否已經(jīng)在緩存中。如果圖像以待處理或已處理狀態(tài)被緩存，containsKey將返回true。使用statusForKey方法可以獲得更細(xì)粒度的信息。

通常情況下，這個(gè)類(lèi)不會(huì)直接使用。ImageProvider類(lèi)及其子類(lèi)會(huì)自動(dòng)處理圖像緩存。

在PaintingBinding中保留了這個(gè)緩存的共享實(shí)例，并可以通過(guò)painting庫(kù)中的imageCache頂級(jí)屬性獲取。

_pendingImages、_cache、_liveImages

final Map<Object, _PendingImage> _pendingImages = <Object, _PendingImage>{};
final Map<Object, _CachedImage> _cache = <Object, _CachedImage>{};
/// ImageStreamCompleters with at least one listener. These images may or may
/// not fit into the _pendingImages or _cache objects.
///
/// Unlike _cache, the [_CachedImage] for this may have a null byte size.
final Map<Object, _LiveImage> _liveImages = <Object, _LiveImage>{};

這段代碼定義了三個(gè) Map 對(duì)象來(lái)實(shí)現(xiàn)圖片的緩存機(jī)制。其中：

• _pendingImages：用于緩存正在加載中的圖片，鍵為圖片的標(biāo)識(shí)符，值為 _PendingImage 對(duì)象。

• _cache：用于緩存已經(jīng)加載完成的圖片，鍵為圖片的標(biāo)識(shí)符，值為 _CachedImage 對(duì)象。

• _liveImages：用于緩存當(dāng)前正在使用中的圖片，即其對(duì)應(yīng)的 ImageStreamCompleter 對(duì)象有至少一個(gè)監(jiān)聽(tīng)器。鍵為圖片的標(biāo)識(shí)符，值為 _LiveImage 對(duì)象。

需要注意的是，_liveImages 中的 _LiveImage 對(duì)象的 byteSize 可能為 null，而 _cache 中的 _CachedImage 對(duì)象的 byteSize 總是非空的。這是因?yàn)?nbsp;_cache 中的圖片已經(jīng)加載完成并占用了內(nèi)存，而 _liveImages 中的圖片可能還處于加載中或者被釋放了內(nèi)存，因此其大小可能還未確定或者已經(jīng)變?yōu)?nbsp;null。

maximumSize、currentSize

/// Maximum number of entries to store in the cache.
///
/// Once this many entries have been cached, the least-recently-used entry is
/// evicted when adding a new entry.
int get maximumSize => _maximumSize;
int _maximumSize = _kDefaultSize;
/// Changes the maximum cache size.
///
/// If the new size is smaller than the current number of elements, the
/// extraneous elements are evicted immediately. Setting this to zero and then
/// returning it to its original value will therefore immediately clear the
/// cache.
set maximumSize(int value) {
  assert(value != null);
  assert(value >= 0);
  if (value == maximumSize) {
    return;
  }
  TimelineTask? timelineTask;
  if (!kReleaseMode) {
    timelineTask = TimelineTask()..start(
      'ImageCache.setMaximumSize',
      arguments: <String, dynamic>{'value': value},
    );
  }
  _maximumSize = value;
  if (maximumSize == 0) {
    clear();
  } else {
    _checkCacheSize(timelineTask);
  }
  if (!kReleaseMode) {
    timelineTask!.finish();
  }
}
/// The current number of cached entries.
int get currentSize => _cache.length;
/// Maximum size of entries to store in the cache in bytes.
///
/// Once more than this amount of bytes have been cached, the
/// least-recently-used entry is evicted until there are fewer than the
/// maximum bytes.
int get maximumSizeBytes => _maximumSizeBytes;
int _maximumSizeBytes = _kDefaultSizeBytes;
/// Changes the maximum cache bytes.
///
/// If the new size is smaller than the current size in bytes, the
/// extraneous elements are evicted immediately. Setting this to zero and then
/// returning it to its original value will therefore immediately clear the
/// cache.
set maximumSizeBytes(int value) {
  assert(value != null);
  assert(value >= 0);
  if (value == _maximumSizeBytes) {
    return;
  }
  TimelineTask? timelineTask;
  if (!kReleaseMode) {
    timelineTask = TimelineTask()..start(
      'ImageCache.setMaximumSizeBytes',
      arguments: <String, dynamic>{'value': value},
    );
  }
  _maximumSizeBytes = value;
  if (_maximumSizeBytes == 0) {
    clear();
  } else {
    _checkCacheSize(timelineTask);
  }
  if (!kReleaseMode) {
    timelineTask!.finish();
  }
}
/// The current size of cached entries in bytes.
int get currentSizeBytes => _currentSizeBytes;
int _currentSizeBytes = 0;

maximumSize和maximumSizeBytes用于控制緩存的大小。maximumSize是緩存中最多可以存儲(chǔ)的元素?cái)?shù)，超出該限制時(shí)，添加新的元素會(huì)導(dǎo)致最近最少使用的元素被清除。maximumSizeBytes是緩存中最多可以存儲(chǔ)的字節(jié)數(shù)，超出該限制時(shí)，添加新元素會(huì)導(dǎo)致最近最少使用的元素被清除，直到緩存中元素的字節(jié)總數(shù)小于最大值。currentSize和currentSizeBytes分別表示當(dāng)前緩存中元素的數(shù)量和字節(jié)總數(shù)。在緩存大小發(fā)生變化時(shí)，會(huì)自動(dòng)清除多出的元素。

clear

/// Evicts all pending and keepAlive entries from the cache.
///
/// This is useful if, for instance, the root asset bundle has been updated
/// and therefore new images must be obtained.
///
/// Images which have not finished loading yet will not be removed from the
/// cache, and when they complete they will be inserted as normal.
///
/// This method does not clear live references to images, since clearing those
/// would not reduce memory pressure. Such images still have listeners in the
/// application code, and will still remain resident in memory.
///
/// To clear live references, use [clearLiveImages].
void clear() {
  if (!kReleaseMode) {
    Timeline.instantSync(
      'ImageCache.clear',
      arguments: <String, dynamic>{
        'pendingImages': _pendingImages.length,
        'keepAliveImages': _cache.length,
        'liveImages': _liveImages.length,
        'currentSizeInBytes': _currentSizeBytes,
      },
    );
  }
  for (final _CachedImage image in _cache.values) {
    image.dispose();
  }
  _cache.clear();
  for (final _PendingImage pendingImage in _pendingImages.values) {
    pendingImage.removeListener();
  }
  _pendingImages.clear();
  _currentSizeBytes = 0;
}

clear()方法用于清除ImageCache中所有的待定和保持活動(dòng)狀態(tài)的圖像緩存。這對(duì)于需要獲取新圖像的情況非常有用，例如根資產(chǎn)包已更新。尚未完成加載的圖像不會(huì)從緩存中刪除，當(dāng)它們完成時(shí)，它們將像往常一樣被插入。

此方法不清除圖像的活動(dòng)引用，因?yàn)檫@樣做不會(huì)減少內(nèi)存壓力。這些圖像仍然在應(yīng)用程序代碼中具有偵聽(tīng)器，并且仍將保留在內(nèi)存中。如果要清除活動(dòng)引用，請(qǐng)使用clearLiveImages()方法。

evict

/// Evicts a single entry from the cache, returning true if successful.
///
/// Pending images waiting for completion are removed as well, returning true
/// if successful. When a pending image is removed the listener on it is
/// removed as well to prevent it from adding itself to the cache if it
/// eventually completes.
///
/// If this method removes a pending image, it will also remove
/// the corresponding live tracking of the image, since it is no longer clear
/// if the image will ever complete or have any listeners, and failing to
/// remove the live reference could leave the cache in a state where all
/// subsequent calls to [putIfAbsent] will return an [ImageStreamCompleter]
/// that will never complete.
///
/// If this method removes a completed image, it will _not_ remove the live
/// reference to the image, which will only be cleared when the listener
/// count on the completer drops to zero. To clear live image references,
/// whether completed or not, use [clearLiveImages].
///
/// The `key` must be equal to an object used to cache an image in
/// [ImageCache.putIfAbsent].
///
/// If the key is not immediately available, as is common, consider using
/// [ImageProvider.evict] to call this method indirectly instead.
///
/// The `includeLive` argument determines whether images that still have
/// listeners in the tree should be evicted as well. This parameter should be
/// set to true in cases where the image may be corrupted and needs to be
/// completely discarded by the cache. It should be set to false when calls
/// to evict are trying to relieve memory pressure, since an image with a
/// listener will not actually be evicted from memory, and subsequent attempts
/// to load it will end up allocating more memory for the image again. The
/// argument must not be null.
///
/// See also:
///
///  * [ImageProvider], for providing images to the [Image] widget.
bool evict(Object key, { bool includeLive = true }) {
  assert(includeLive != null);
  if (includeLive) {
    // Remove from live images - the cache will not be able to mark
    // it as complete, and it might be getting evicted because it
    // will never complete, e.g. it was loaded in a FakeAsync zone.
    // In such a case, we need to make sure subsequent calls to
    // putIfAbsent don't return this image that may never complete.
    final _LiveImage? image = _liveImages.remove(key);
    image?.dispose();
  }
  final _PendingImage? pendingImage = _pendingImages.remove(key);
  if (pendingImage != null) {
    if (!kReleaseMode) {
      Timeline.instantSync('ImageCache.evict', arguments: <String, dynamic>{
        'type': 'pending',
      });
    }
    pendingImage.removeListener();
    return true;
  }
  final _CachedImage? image = _cache.remove(key);
  if (image != null) {
    if (!kReleaseMode) {
      Timeline.instantSync('ImageCache.evict', arguments: <String, dynamic>{
        'type': 'keepAlive',
        'sizeInBytes': image.sizeBytes,
      });
    }
    _currentSizeBytes -= image.sizeBytes!;
    image.dispose();
    return true;
  }
  if (!kReleaseMode) {
    Timeline.instantSync('ImageCache.evict', arguments: <String, dynamic>{
      'type': 'miss',
    });
  }
  return false;
}

從緩存中刪除一個(gè)條目，如果成功則返回true。

同時(shí)刪除等待完成的待處理圖像，如果成功則返回true。當(dāng)刪除待處理的圖像時(shí)，也將移除其上的監(jiān)聽(tīng)器，以防止其在最終完成后添加到緩存中。

如果此方法刪除了待處理的圖像，則它還將刪除圖像的相應(yīng)實(shí)時(shí)跟蹤，因?yàn)榇藭r(shí)無(wú)法確定圖像是否會(huì)完成或具有任何偵聽(tīng)器，并且未刪除實(shí)時(shí)引用可能會(huì)使緩存處于狀態(tài)，其中所有后續(xù)對(duì) [putIfAbsent] 的調(diào)用都將返回一個(gè)永遠(yuǎn)不會(huì)完成的 [ImageStreamCompleter]。

如果此方法刪除了已完成的圖像，則不會(huì)刪除圖像的實(shí)時(shí)引用，只有在監(jiān)聽(tīng)器計(jì)數(shù)為零時(shí)才會(huì)清除實(shí)時(shí)圖像引用。要清除已完成或未完成的實(shí)時(shí)圖像引用，請(qǐng)使用 [clearLiveImages]。

key 必須等于用于在 [ImageCache.putIfAbsent] 中緩存圖像的對(duì)象。

如果 key 不是立即可用的對(duì)象（這很常見(jiàn)），請(qǐng)考慮使用 [ImageProvider.evict] 間接調(diào)用此方法。

includeLive 參數(shù)確定是否也應(yīng)將仍具有樹(shù)中偵聽(tīng)器的圖像清除。在圖像可能損壞并需要完全丟棄緩存的情況下，應(yīng)將此參數(shù)設(shè)置為true。在嘗試緩解內(nèi)存壓力的情況下，應(yīng)將其設(shè)置為false，因?yàn)榫哂袀陕?tīng)器的圖像實(shí)際上不會(huì)從內(nèi)存中清除，后續(xù)嘗試加載它將再次為圖像分配更多內(nèi)存。該參數(shù)不能為空。

_touch

/// Updates the least recently used image cache with this image, if it is
/// less than the [maximumSizeBytes] of this cache.
///
/// Resizes the cache as appropriate to maintain the constraints of
/// [maximumSize] and [maximumSizeBytes].
void _touch(Object key, _CachedImage image, TimelineTask? timelineTask) {
  assert(timelineTask != null);
  if (image.sizeBytes != null && image.sizeBytes! <= maximumSizeBytes && maximumSize > 0) {
    _currentSizeBytes += image.sizeBytes!;
    _cache[key] = image;
    _checkCacheSize(timelineTask);
  } else {
    image.dispose();
  }
}

如果圖片的大小小于此緩存的 [maximumSizeBytes]，則使用此圖像更新最近最少使用的圖像緩存。

調(diào)整緩存大小以滿(mǎn)足 [maximumSize] 和 [maximumSizeBytes] 的約束。

_checkCacheSize

// Remove images from the cache until both the length and bytes are below
// maximum, or the cache is empty.
void _checkCacheSize(TimelineTask? timelineTask) {
  final Map<String, dynamic> finishArgs = <String, dynamic>{};
  TimelineTask? checkCacheTask;
  if (!kReleaseMode) {
    checkCacheTask = TimelineTask(parent: timelineTask)..start('checkCacheSize');
    finishArgs['evictedKeys'] = <String>[];
    finishArgs['currentSize'] = currentSize;
    finishArgs['currentSizeBytes'] = currentSizeBytes;
  }
  while (_currentSizeBytes > _maximumSizeBytes || _cache.length > _maximumSize) {
    final Object key = _cache.keys.first;
    final _CachedImage image = _cache[key]!;
    _currentSizeBytes -= image.sizeBytes!;
    image.dispose();
    _cache.remove(key);
    if (!kReleaseMode) {
      (finishArgs['evictedKeys'] as List<String>).add(key.toString());
    }
  }
  if (!kReleaseMode) {
    finishArgs['endSize'] = currentSize;
    finishArgs['endSizeBytes'] = currentSizeBytes;
    checkCacheTask!.finish(arguments: finishArgs);
  }
  assert(_currentSizeBytes >= 0);
  assert(_cache.length <= maximumSize);
  assert(_currentSizeBytes <= maximumSizeBytes);
}

這段代碼實(shí)現(xiàn)了檢查緩存大小的邏輯，用于在緩存大小超過(guò)最大限制時(shí)從緩存中移除圖像以釋放內(nèi)存。

該方法首先創(chuàng)建一個(gè)空的字典對(duì)象 finishArgs 用于保存一些統(tǒng)計(jì)數(shù)據(jù)，然后在非生產(chǎn)環(huán)境下創(chuàng)建一個(gè)時(shí)間線(xiàn)任務(wù) checkCacheTask，用于記錄緩存檢查的時(shí)間。如果檢查任務(wù)存在，則將 evictedKeys、currentSize 和 currentSizeBytes 添加到 finishArgs 中。

然后，使用 while 循環(huán)，當(dāng)緩存大小超過(guò)最大限制時(shí)，從 _cache 字典中刪除第一個(gè)元素，并釋放相關(guān)圖像的內(nèi)存。如果 checkCacheTask 存在，則將已刪除的元素的鍵添加到 evictedKeys 列表中。

當(dāng)循環(huán)結(jié)束時(shí)，將 endSize 和 endSizeBytes 添加到 finishArgs 中，表示緩存檢查后的當(dāng)前大小和字節(jié)數(shù)。最后，如果 checkCacheTask 存在，則完成任務(wù)并將 finishArgs 作為參數(shù)傳遞。

最后，這個(gè)方法斷言 _currentSizeBytes 必須大于等于零， _cache 的長(zhǎng)度必須小于等于 maximumSize， _currentSizeBytes 必須小于等于 maximumSizeBytes。

_trackLiveImage

void _trackLiveImage(Object key, ImageStreamCompleter completer, int? sizeBytes) {
  // Avoid adding unnecessary callbacks to the completer.
  _liveImages.putIfAbsent(key, () {
    // Even if no callers to ImageProvider.resolve have listened to the stream,
    // the cache is listening to the stream and will remove itself once the
    // image completes to move it from pending to keepAlive.
    // Even if the cache size is 0, we still add this tracker, which will add
    // a keep alive handle to the stream.
    return _LiveImage(
      completer,
      () {
        _liveImages.remove(key);
      },
    );
  }).sizeBytes ??= sizeBytes;
}

putIfAbsent

/// Returns the previously cached [ImageStream] for the given key, if available;
/// if not, calls the given callback to obtain it first. In either case, the
/// key is moved to the 'most recently used' position.
///
/// The arguments must not be null. The `loader` cannot return null.
///
/// In the event that the loader throws an exception, it will be caught only if
/// `onError` is also provided. When an exception is caught resolving an image,
/// no completers are cached and `null` is returned instead of a new
/// completer.
ImageStreamCompleter? putIfAbsent(Object key, ImageStreamCompleter Function() loader, { ImageErrorListener? onError }) {
  assert(key != null);
  assert(loader != null);
  TimelineTask? timelineTask;
  TimelineTask? listenerTask;
  if (!kReleaseMode) {
    timelineTask = TimelineTask()..start(
      'ImageCache.putIfAbsent',
      arguments: <String, dynamic>{
        'key': key.toString(),
      },
    );
  }
  ImageStreamCompleter? result = _pendingImages[key]?.completer;
  // Nothing needs to be done because the image hasn't loaded yet.
  if (result != null) {
    if (!kReleaseMode) {
      timelineTask!.finish(arguments: <String, dynamic>{'result': 'pending'});
    }
    return result;
  }
  // Remove the provider from the list so that we can move it to the
  // recently used position below.
  // Don't use _touch here, which would trigger a check on cache size that is
  // not needed since this is just moving an existing cache entry to the head.
  final _CachedImage? image = _cache.remove(key);
  if (image != null) {
    if (!kReleaseMode) {
      timelineTask!.finish(arguments: <String, dynamic>{'result': 'keepAlive'});
    }
    // The image might have been keptAlive but had no listeners (so not live).
    // Make sure the cache starts tracking it as live again.
    _trackLiveImage(
      key,
      image.completer,
      image.sizeBytes,
    );
    _cache[key] = image;
    return image.completer;
  }
  final _LiveImage? liveImage = _liveImages[key];
  if (liveImage != null) {
    _touch(
      key,
      _CachedImage(
        liveImage.completer,
        sizeBytes: liveImage.sizeBytes,
      ),
      timelineTask,
    );
    if (!kReleaseMode) {
      timelineTask!.finish(arguments: <String, dynamic>{'result': 'keepAlive'});
    }
    return liveImage.completer;
  }
  try {
    result = loader();
    _trackLiveImage(key, result, null);
  } catch (error, stackTrace) {
    if (!kReleaseMode) {
      timelineTask!.finish(arguments: <String, dynamic>{
        'result': 'error',
        'error': error.toString(),
        'stackTrace': stackTrace.toString(),
      });
    }
    if (onError != null) {
      onError(error, stackTrace);
      return null;
    } else {
      rethrow;
    }
  }
  if (!kReleaseMode) {
    listenerTask = TimelineTask(parent: timelineTask)..start('listener');
  }
  // A multi-frame provider may call the listener more than once. We need do make
  // sure that some cleanup works won't run multiple times, such as finishing the
  // tracing task or removing the listeners
  bool listenedOnce = false;
  // We shouldn't use the _pendingImages map if the cache is disabled, but we
  // will have to listen to the image at least once so we don't leak it in
  // the live image tracking.
  final bool trackPendingImage = maximumSize > 0 && maximumSizeBytes > 0;
  late _PendingImage pendingImage;
  void listener(ImageInfo? info, bool syncCall) {
    int? sizeBytes;
    if (info != null) {
      sizeBytes = info.sizeBytes;
      info.dispose();
    }
    final _CachedImage image = _CachedImage(
      result!,
      sizeBytes: sizeBytes,
    );
    _trackLiveImage(key, result, sizeBytes);
    // Only touch if the cache was enabled when resolve was initially called.
    if (trackPendingImage) {
      _touch(key, image, listenerTask);
    } else {
      image.dispose();
    }
    _pendingImages.remove(key);
    if (!listenedOnce) {
      pendingImage.removeListener();
    }
    if (!kReleaseMode && !listenedOnce) {
      listenerTask!.finish(arguments: <String, dynamic>{
        'syncCall': syncCall,
        'sizeInBytes': sizeBytes,
      });
      timelineTask!.finish(arguments: <String, dynamic>{
        'currentSizeBytes': currentSizeBytes,
        'currentSize': currentSize,
      });
    }
    listenedOnce = true;
  }
  final ImageStreamListener streamListener = ImageStreamListener(listener);
  pendingImage = _PendingImage(result, streamListener);
  if (trackPendingImage) {
    _pendingImages[key] = pendingImage;
  }
  // Listener is removed in [_PendingImage.removeListener].
  result.addListener(streamListener);
  return result;
}

這個(gè)是圖片緩存的核心方法。

clearLiveImages

(調(diào)用此方法不會(huì)減輕內(nèi)存壓力，因?yàn)榛顒?dòng)圖像緩存僅跟蹤同時(shí)由至少一個(gè)其他對(duì)象持有的圖像實(shí)例。)

/// Clears any live references to images in this cache.
///
/// An image is considered live if its [ImageStreamCompleter] has never hit
/// zero listeners after adding at least one listener. The
/// [ImageStreamCompleter.addOnLastListenerRemovedCallback] is used to
/// determine when this has happened.
///
/// This is called after a hot reload to evict any stale references to image
/// data for assets that have changed. Calling this method does not relieve
/// memory pressure, since the live image caching only tracks image instances
/// that are also being held by at least one other object.
void clearLiveImages() {
  for (final _LiveImage image in _liveImages.values) {
    image.dispose();
  }
  _liveImages.clear();
}

清除此緩存中任何圖像的現(xiàn)有引用。

如果一個(gè)圖像的 [ImageStreamCompleter] 至少添加了一個(gè)偵聽(tīng)器并且從未達(dá)到零偵聽(tīng)器，則認(rèn)為該圖像是“現(xiàn)有的”。

[ImageStreamCompleter.addOnLastListenerRemovedCallback] 用于確定是否發(fā)生了這種情況。

在熱重載之后調(diào)用此方法以清除對(duì)已更改資產(chǎn)的圖像數(shù)據(jù)的任何過(guò)時(shí)引用。

調(diào)用此方法不會(huì)減輕內(nèi)存壓力，因?yàn)榛顒?dòng)圖像緩存僅跟蹤同時(shí)由至少一個(gè)其他對(duì)象持有的圖像實(shí)例。

答疑解惑

_pendingImages 正在加載中的緩存，這個(gè)有什么作用呢? 假設(shè)Widget1加載了圖片A,Widget2也在這個(gè)時(shí)候加載了圖片A，那這時(shí)候Widget就復(fù)用了這個(gè)加載中的緩存

_cache 已經(jīng)加載成功的圖片緩存

_liveImages 存活的圖片緩存，看代碼主要是在CacheImage之外再加一層緩存。收到內(nèi)存警告時(shí), 調(diào)用clear()方法清除緩存時(shí), 并不是清除_liveImages, 因?yàn)楣俜浇忉? 因?yàn)檫@樣做不會(huì)減少內(nèi)存壓力。

感謝各位的閱讀，以上就是“Flutter加載圖片流程之ImageCache源碼分析”的內(nèi)容了，經(jīng)過(guò)本文的學(xué)習(xí)后，相信大家對(duì)Flutter加載圖片流程之ImageCache源碼分析這一問(wèn)題有了更深刻的體會(huì)，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是億速云，小編將為大家推送更多相關(guān)知識(shí)點(diǎn)的文章，歡迎關(guān)注！