唠嗑008
唠嗑008

Android 【手撕Glide】--Glide缓存机制

本文源码解析基于Glide 4.6.1
不知道大家最开始使用Glide的原因是什么？我的原因很简单就是冲着那句Glide.with(this).load(url).into(imageview)去的,再加上Google的推荐，就一直沿用至今。以前也不太了解它，就知道它使用简洁而且很火，不过最近看了一些它的源码设计，算是找到了使用Glide理由。我目前的缘由如下：
1、Glide通过高度封装之后，通过外观模式对外提供了非常简洁的API调用，貌似外观模式的很多库都很受欢迎；
2、Glide自动感知生命周期，很节约资源，不会内存泄漏；
3、超级强大的缓存机制；
4、各种图片转换，超级方便。

Android 【手撕Glide】--Glide缓存机制
Android 【手撕Glide】--Glide缓存机制（面试）
Android 【手撕Glide】--Glide是如何关联生命周期的？

我想只要用过Glide的同学都或多或少听过Glide的缓存机制，比如Glide用了3级缓存；又用了Lrucache、DiskLrucache；Glide缓存图片会缓存多张等等。但还是有很多同学对缓存源码和缓存原理没有一个整体的清晰的思路，本文就是来解决这个问题的，为了高效的学习，本文按照如下思路来讲解Glide缓存机制：

  • Glide缓存简介
  • Glide缓存Key
  • Glide内存缓存的读写
  • Glide磁盘缓存的读写

Glide缓存简介

三级缓存or二级缓存？
在没学习源码之前，我连这个最基本的概念都不确定，以前老是听人说缓存是内存--->磁盘--->网络这样的方式去获取图片资源的，但这就是3级缓存吗？明显不是，这个只是2级缓存；Glide也是按照这种方式获取图片的，但是略有不同，Glide将它的缓存分为2个大的部分，一个是内存缓存，一个是硬盘缓存。其中内存缓存又分为2种，弱引用和Lrucache；磁盘缓存就是DiskLrucache，DiskLrucache算法和Lrucache差不多的，所以现在看起来Glide3级缓存的话应该是WeakReference + Lrucache + DiskLrucache。

内存缓存的主要作用是防止应用重复将图片数据读取到内存当中；而硬盘缓存的主要作用是防止应用重复从网络或其他地方下载和读取数据。

Glide缓存Key

缓存是为了解决重复加载问题，那必然要有一个key来区分不同的图片资源。从下面生成key的代码可以看出Glide生成key的方式远比我们想象的要复杂，决定缓存Key的参数有8种，其中包括图片URL、宽、高。

#Engine.load()
//生成缓存key
EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);

这里可以得出一个结论，几乎任意配置的改变都会导致同一张图片生成多个缓存key。举个例子：同一张图片加载到2个不同大小的ImageView会生成2个缓存图片。至于EngineKey的作用，当然是用于读取／写入缓存图片的时候用到的，别着急，后面的流程你会多次看到的。

Glide内存缓存的读写

这里先从内存缓存说起吧，首先Glide默认开启了内存缓存，当然你可以选择手动关闭。注意：只有开启了内存才能使用下面的内存缓存功能。

skipMemoryCache(true) //关闭内存缓存

前面提到过内存缓存是通过弱引用+LruCache的方式实现的。那内存缓存在哪里实现的呢？还记得刚才在Engine#load()方法中生成缓存Key吗？内存缓存的代码也在这里实现的，下面一起看一下源码：

public  LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class resourceClass,
      Class transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map, Transformation> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb) {
    Util.assertMainThread();
    long startTime = LogTime.getLogTime();

    //1.生成缓存key
    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);

    //2.从弱引用读取内存缓存
    EngineResource active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return null;
    }

    //3.从LruCache读取缓存
    EngineResource cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }
 
    //...省略
    //4.通过线程池从网络加载图片

看一下内存缓存部分的逻辑，首先通过loadFromActiveResources从弱引用读取；如果没有再通过loadFromCache从LruCache读取；2者中的任意一个获取到数据就会调用onResourceReady就是将资源回调给ImageView去加载。

Engine#loadFromActiveResources()：从弱引用读取缓存

public class Engine  {
  private final ActiveResources activeResources;

private EngineResource loadFromActiveResources(Key key, boolean isMemoryCacheable) {
//没有开启内存缓存就直接返回   
 if (!isMemoryCacheable) {
      return null;
    }
    //弱引用获取缓存图片
    EngineResource active = activeResources.get(key);
    if (active != null) {
      active.acquire();
    }

    return active;
  }
}

#ActiveResources#get()
class ActiveResources {
    //弱引用的hashmap
    Map activeEngineResources = new HashMap<>();

    EngineResource get(Key key) {
    //1.从弱引用的map获取图片资源
    ResourceWeakReference activeRef = activeEngineResources.get(key);
    if (activeRef == null) {
      return null;
    }
    //2.最终需要的资源对象
    EngineResource active = activeRef.get();
    if (active == null) {
      cleanupActiveReference(activeRef);
    }
    return active;
  }
}

这里的逻辑也不复杂，通过弱引用的hashmap来存储资源，Key是缓存key，ResourceWeakReference代表资源，它继承WeakReference。首先从弱引用的map获取图片资源，然后通过弱引用的get()方法获取最终需要的对象，如果activeRef.get();拿不到（可能已经被系统GC回收），那就clear(从弱引用中移除，清除资源等)。

再回到刚才Engine的load方法中，如果loadFromActiveResources获取不到，会调用loadFromCache来获取。

Engine#loadFromCache()：从LruCache读取缓存

public class Engine  {
  private final ActiveResources activeResources;
 //Lrucache对象
    private final MemoryCache cache;

private EngineResource loadFromCache(Key key, boolean isMemoryCacheable) {
    if (!isMemoryCacheable) {
      return null;
    }
    //从lrucache获取
    EngineResource cached = getEngineResourceFromCache(key);
    if (cached != null) {
      cached.acquire();
      //存到弱引用的HashMap
      activeResources.activate(key, cached);
    }
    return cached;
  }

private EngineResource getEngineResourceFromCache(Key key) {
    //从lrucache删除资源
    Resource cached = cache.remove(key);

    final EngineResource result;
    if (cached == null) {
      result = null;
    } else if (cached instanceof EngineResource) {
      // Save an object allocation if we've cached an EngineResource (the typical case).
      result = (EngineResource) cached;
    } else {
      result = new EngineResource<>(cached, true /*isMemoryCacheable*/, true /*isRecyclable*/);
    }
    return result;
  }
}

逻辑比较简单，通过lrucache获取图片资源，如果获取到的话就会从LruCache中删除这张图片，然后会调用acquire()方法和activate()方法,其中activate()是把取到的数据会存到弱引用中，说白了就是把图片从LruCache转移到弱引用。

EngineResource# acquire()

class EngineResource implements Resource {
  //图片引用计数器 
 private int acquired;

void acquire() {
    if (isRecycled) {
      throw new IllegalStateException("Cannot acquire a recycled resource");
    }
    if (!Looper.getMainLooper().equals(Looper.myLooper())) {
      throw new IllegalThreadStateException("Must call acquire on the main thread");
    }
    ++acquired;
  }
}

这里只是将acquired+1，那这个acquired变量是什么意思呢？它实际上是图片引用计数器 ，EngineResource是用一个acquired变量用来记录图片被引用的次数，调用acquire()方法会让变量加1，调用release()方法会让变量减1，release()方法后面调用的时候会讲到。。

到这里，内存缓存的读取就说完了，下面讲一下内存缓存的写入。很明显缓存的写入是在加载图片之后，所以回到刚才Engine#load()方法

 public  LoadStatus load(//一系列参数) {

  //...省略

  //1.从弱引用读取内存缓存
   loadFromActiveResources()

    //2.从LruCache读取缓存
 loadFromCache();

    //3.通过EngineJob加载图片

    EngineJob engineJob =
        engineJobFactory.build();

    DecodeJob decodeJob =
        decodeJobFactory.build();

    jobs.put(key, engineJob);

    engineJob.addCallback(cb);
    //通过线程池加载图片
    engineJob.start(decodeJob);

  }

这里有2个关键的对象，EngineJob和DecodeJob，EngineJob 内部维护了线程池，用来管理资源加载，当资源加载完毕的时候通知回调； DecodeJob 是线程池中的一个任务。最后通过start()方法加载图片,实际上是在DecodeJob的run()方法中完成的，当图片加载完成，最终会回调EngineJob#onResourceReady ()

#EngineJob
public void onResourceReady(Resource resource, DataSource dataSource) {
    this.resource = resource;
    this.dataSource = dataSource;
    MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
  }

@Override
public boolean handleMessage(Message message) {
  EngineJob job = (EngineJob) message.obj;
  switch (message.what) {
    case MSG_COMPLETE:
      job.handleResultOnMainThread();
      break;
    case MSG_EXCEPTION:
      job.handleExceptionOnMainThread();
      break;
    case MSG_CANCELLED:
      job.handleCancelledOnMainThread();
      break;
    default:
      throw new IllegalStateException("Unrecognized message: " + message.what);
  }
  return true;
}

EngineJob#handleResultOnMainThread ()

void handleResultOnMainThread() {
    stateVerifier.throwIfRecycled();
    if (isCancelled) {
      resource.recycle();
      release(false /*isRemovedFromQueue*/);
      return;
    } else if (cbs.isEmpty()) {
      throw new IllegalStateException("Received a resource without any callbacks to notify");
    } else if (hasResource) {
      throw new IllegalStateException("Already have resource");
    }
    engineResource = engineResourceFactory.build(resource, isCacheable);
    hasResource = true;

    // Hold on to resource for duration of request so we don't recycle it in the middle of
    // notifying if it synchronously released by one of the callbacks.
    //1.图片引用计数器+1    
    engineResource.acquire();
    //2.回调到EngineJob处理
    listener.onEngineJobComplete(this, key, engineResource);

    //noinspection ForLoopReplaceableByForEach to improve perf
    //3.遍历加载的图片
    for (int i = 0, size = cbs.size(); i < size; i++) {
      ResourceCallback cb = cbs.get(i);
      if (!isInIgnoredCallbacks(cb)) {
        //图片引用计数器+1    
        engineResource.acquire();
        //将资源回调给ImageView去加载
        cb.onResourceReady(engineResource, dataSource);
      }
    }
    // Our request is complete, so we can release the resource.
    //4.释放资源，图片引用计数器-1  
    engineResource.release();

    release(false /*isRemovedFromQueue*/);
  }

这里一共有4步：
1、图片引用计数器+1；
2、listener.onEngineJobComplete()，这个listener是EngineJobListener接口对象，这里是将结果回调给Engine#onEngineJobComplete()处理；
3、遍历遍历加载的图片，每加载到一张图片，引用计数器+1 ，并且会将资源回调给ImageView去加载；
4、释放资源，图片引用计数器-1 。

public void onEngineJobComplete(EngineJob engineJob, Key key, EngineResource resource) {
    Util.assertMainThread();
    // A null resource indicates that the load failed, usually due to an exception.
    if (resource != null) {
      resource.setResourceListener(key, this);

      if (resource.isCacheable()) {
        //把资源放到弱引用
        activeResources.activate(key, resource);
      }
    }

    jobs.removeIfCurrent(key, engineJob);
  }

可以看到，这里把资源放到弱引用，也就是内存缓存的写入了。但是LruCache缓存貌似还没有出现，再回头看看刚才的Engine#onEngineJobComplete()方法，最后还调用了还调用了 engineResource.release()方法来释放资源，还记得之前讲过这个方法吗，在获取内存缓存的时候会调用acquire()，使得acquired+1；而调用release()方法会让acquired -1。

EngineResource#release()

class EngineResource implements Resource {
  //图片引用计数器 
 private int acquired;

void release() {
    if (acquired <= 0) {
      throw new IllegalStateException("Cannot release a recycled or not yet acquired resource");
    }
    if (!Looper.getMainLooper().equals(Looper.myLooper())) {
      throw new IllegalThreadStateException("Must call release on the main thread");
    }
    if (--acquired == 0) {
      listener.onResourceReleased(key, this);
    }
  }
}

调用release()的时机主要是：加载网络图片时暂停请求／加载完毕以及清除资源。release()将acquired-1，并且当acquired==0的时候，会调用listener.onResourceReleased()方法，而这个listener正是Engine。

Engine#onResourceReleased()

public class Engine implements EngineJobListener,
    MemoryCache.ResourceRemovedListener,
    EngineResource.ResourceListener {

@Override
  public void onResourceReleased(Key cacheKey, EngineResource resource) {
    Util.assertMainThread();
    //从弱引用集合activeResources中移除资源
    activeResources.deactivate(cacheKey);
    if (resource.isCacheable()) {
      //放入LruCache缓存
      cache.put(cacheKey, resource);
    } else {
      //回收资源
      resourceRecycler.recycle(resource);
    }
  }
}

这个onResourceReleased ()方法也不复杂，作用是释放资源，先从弱引用集合activeResources中移除资源，然后再把图片资源放入LruCache缓存。

注意：在上面的调用EngineJob#handleResultOnMainThread ()去加载图片等时候，如果加载图片成功，那么acquired>=1，说明有图片正在被引用；而等到暂停请求／退出页面的时候再次调用release()时，acquired==0才会去调用onResourceReleased ()把缓存从弱引用转移到Lrucache。

小结

这个acquired变量是用来记录图片被引用的次数，调用acquire()方法会让变量加1，调用release()方法会让变量减1。当调用loadFromActiveResources()、loadFromCache()、EngineJob#handleResultOnMainThread()获取图片的时候都会执行acquire()方法；当暂停请求或者加载完毕或者清除资源时会调用release()方法。

注意：从弱引用取缓存，拿到的话，引用计数+1；从LruCache中拿缓存，拿到的话，引用计数也是+1，同时把LruCache缓存转移到弱应用缓存池中；从EngineJob去加载图片，拿到的话，引用计数也是+1，会把图片放到弱引用。反过来，一旦没有地方正在使用这个资源，就会将其从弱引用中转移到LruCache缓存池中。这也说明了正在使用中的图片使用弱引用来进行缓存，暂时不用的图片使用LruCache来进行缓存的功能。

Glide磁盘缓存的读写

Glide5大磁盘缓存策略
DiskCacheStrategy.DATA: 只缓存原始图片；
DiskCacheStrategy.RESOURCE:只缓存转换过后的图片；
DiskCacheStrategy.ALL:既缓存原始图片，也缓存转换过后的图片；对于远程图片，缓存 DATA和 RESOURCE；对于本地图片，只缓存 RESOURCE；
DiskCacheStrategy.NONE：不缓存任何内容；
DiskCacheStrategy.AUTOMATIC：默认策略，尝试对本地和远程图片使用最佳的策略。当下载网络图片时，使用DATA；对于本地图片，使用RESOURCE；

上面讲内存缓存写入的时候说到过，如果在内存缓存中没获取到数据，就通过DecodeJob 和EngineJob加载图片。EngineJob 内部维护了线程池，用来管理资源加载，当资源加载完毕的时候通知回调； DecodeJob 是线程池中的一个任务。

DecodeJob#run()

public void run() {
   ...
    try {
      if (isCancelled) {
        notifyFailed();
        return;
      }
      runWrapped();
    } 
    ...
  }

  private void runWrapped() {
    switch (runReason) {
      case INITIALIZE:
        stage = getNextStage(Stage.INITIALIZE);
        currentGenerator = getNextGenerator();
        runGenerators();
        break;
      case SWITCH_TO_SOURCE_SERVICE:
        runGenerators();
        break;
      case DECODE_DATA:
        decodeFromRetrievedData();
        break;
      default:
        throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
  }

这里会执行到runWrapper()方法，对于一个新的任务，会执行第一个分支。stage:用来决定 DecodeJob 状态，表示数据的加载状态；currentGenerator:是解析生成器，有多个实现类：ResourcesCacheGenerator、SourceGenerator、DataCacheGenerator，它们负责各种硬盘缓存策略下的缓存管理:

  • ResourceCacheGenerator:管理变换之后的缓存数据；
  • SourceGenerator:管理未经转换的原始缓存数据；
  • SourceGenerator：直接从网络下载解析数据。

接下来会调用3个方法getNextStage getNextGenerator runGenerators()，

#DecodeJob
private Stage getNextStage(Stage current) {
    switch (current) {
      case INITIALIZE:
        return diskCacheStrategy.decodeCachedResource()
            ? Stage.RESOURCE_CACHE : getNextStage(Stage.RESOURCE_CACHE);
      case RESOURCE_CACHE:
        return diskCacheStrategy.decodeCachedData()
            ? Stage.DATA_CACHE : getNextStage(Stage.DATA_CACHE);
      case DATA_CACHE:
        // Skip loading from source if the user opted to only retrieve the resource from cache.
        return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
      case SOURCE:
      case FINISHED:
        return Stage.FINISHED;
      default:
        throw new IllegalArgumentException("Unrecognized stage: " + current);
    }
  }

private DataFetcherGenerator getNextGenerator() {
    switch (stage) {
      case RESOURCE_CACHE:
        return new ResourceCacheGenerator(decodeHelper, this);
      case DATA_CACHE:
        return new DataCacheGenerator(decodeHelper, this);
      case SOURCE:
        return new SourceGenerator(decodeHelper, this);
      case FINISHED:
        return null;
      default:
        throw new IllegalStateException("Unrecognized stage: " + stage);
    }
  }

private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    while (!isCancelled && currentGenerator != null
        && !(isStarted = currentGenerator.startNext())) {
      stage = getNextStage(stage);
      currentGenerator = getNextGenerator();

      if (stage == Stage.SOURCE) {
        reschedule();
        return;
      }
    }
    // We've run out of stages and generators, give up.
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
      notifyFailed();
    }

    // Otherwise a generator started a new load and we expect to be called back in
    // onDataFetcherReady.
  }

别怕啊，写到这里我也很恶心了，本来想要一笔带过的，但是发现网上没什么博客能说清楚这个问题,还是写一下吧。这个地方之所以这么麻烦，是因为缓存策略的原因。

还是回到上面的runWrapped()方法，它先是调用了getNextStage(Stage.INITIALIZE),于是进入getNextStage()第一个分支，根据缓存策略返回Stage，由于我用的是默认的缓存策略，这里decodeCachedResource返回true，于是getNextStage()方法返回Stage.RESOURCE_CACHE；然后执行getNextGenerator方法，根据上一步的stage，这里执行第一个分支，返回ResourceCacheGenerator,这个方法返回的3个Generator对象都是用于加载图片资源的；接着调用runGenerators()方法：它通过while循环来获取那3个解析生成器Generator，循环条件主要是currentGenerator.startNext(),它的实际调用在那3个Generator里面，在方法内部又会获取stage和currentGenerator，当stage == Stage.SOURCE时会跳出循环。如果是第一次从网络加载图片的话，最终数据的加载会交给 SourceGenerator 进行;如果是从磁盘缓存获取的话会根据缓存策略的不同从ResourceCacheGenerator或者DataCacheGenerator获取。

先来看一下ResourceCacheGenerator的startNext()方法，果不其然，里面先是构建了缓存key，然后从DiskLruCache获取到了缓存图片。

#ResourceCacheGenerator
  public boolean startNext() {
    List sourceIds = helper.getCacheKeys();
    if (sourceIds.isEmpty()) {
      return false;
    }
    List> resourceClasses = helper.getRegisteredResourceClasses();
    if (resourceClasses.isEmpty()) {
      if (File.class.equals(helper.getTranscodeClass())) {
        return false;
      }
    }
    while (modelLoaders == null || !hasNextModelLoader()) {
      resourceClassIndex++;
      if (resourceClassIndex >= resourceClasses.size()) {
        sourceIdIndex++;
        if (sourceIdIndex >= sourceIds.size()) {
          return false;
        }
        resourceClassIndex = 0;
      }

      Key sourceId = sourceIds.get(sourceIdIndex);
      Class resourceClass = resourceClasses.get(resourceClassIndex);
      Transformation transformation = helper.getTransformation(resourceClass);
      currentKey =
          new ResourceCacheKey( // 1 构建获取缓存信息的键
              helper.getArrayPool(),
              sourceId,
              helper.getSignature(),
              helper.getWidth(),
              helper.getHeight(),
              transformation,
              resourceClass,
              helper.getOptions());
      cacheFile = helper.getDiskCache().get(currentKey); // 2 从缓存中获取缓存信息
      if (cacheFile != null) {
        sourceKey = sourceId;
        modelLoaders = helper.getModelLoaders(cacheFile);
        modelLoaderIndex = 0;
      }
    }

    loadData = null;
    boolean started = false;
    while (!started && hasNextModelLoader()) {
      ModelLoader modelLoader = modelLoaders.get(modelLoaderIndex++); // 3 使用文件方式从缓存中读取缓存数据
      loadData = modelLoader.buildLoadData(cacheFile,
          helper.getWidth(), helper.getHeight(), helper.getOptions());
      if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
        started = true;
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }

    return started;
  }

这里是通过ResourceCacheGenerator获取的缓存图片，其实DataCacheGenerator也是差不多的。到这里磁盘缓存读取就说完了，下面来看一下磁盘缓存的写入。不用想，是第一次从网络加载图片时写入的，第一次从网络加载时，会调用SourceGenerator#startNext()方法：

#SourceGenerator
public boolean startNext() {
    //判断是否有可以用于缓存数据
    if (dataToCache != null) {
      Object data = dataToCache;
      dataToCache = null;
      //调用disklrucache缓存
      cacheData(data);
    }

    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
      return true;
    }
    sourceCacheGenerator = null;

    loadData = null;
    boolean started = false;
    while (!started && hasNextModelLoader()) {
      loadData = helper.getLoadData().get(loadDataListIndex++);
      if (loadData != null
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
          || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
        started = true;
        //DataFetcher加载数据
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }
    return started;
  }

这里用的是SourceGenerator的startNext()方法，其它2个Generator的实现是不一样的。先判断是否有可以用于缓存的数据，由于是第一次加载网络图片，所以是没有的，然后通过DataFetcher加载数据，具体来说网络的话是通过HttpUrlFetcher来实现的。

HttpUrlFetcher#loadData()

public void loadData(@NonNull Priority priority,
      @NonNull DataCallback callback) {
    long startTime = LogTime.getLogTime();
    try {
      //加载数据获得文件输入流
      InputStream result = loadDataWithRedirects(glideUrl.toURL(), 0, null, glideUrl.getHeaders());
      //在 SourceGenerator 回调
      callback.onDataReady(result);
    } catch (IOException e) {
      if (Log.isLoggable(TAG, Log.DEBUG)) {
        Log.d(TAG, "Failed to load data for url", e);
      }
      callback.onLoadFailed(e);
    } finally {
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Finished http url fetcher fetch in " + LogTime.getElapsedMillis(startTime));
      }
    }
  }

通过HttpURLConnection来获取InputStream，然后在 SourceGenerator 回调。

SourceGenerator #onDataReady ()

#SourceGenerator
public void onDataReady(Object data) {
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
      //保存图片资源数据
      dataToCache = data;
      // We might be being called back on someone else's thread. Before doing anything, we should
      // reschedule to get back onto Glide's thread.
      cb.reschedule(); //回调
    } else {
      cb.onDataFetcherReady(loadData.sourceKey, data, loadData.fetcher,
          loadData.fetcher.getDataSource(), originalKey);
    }
  }

这里先是保存数据，然后回调到DecodeJob中， 将会根据当前的stage从 run() 方法开始执行一遍，并再次调用SourceGenerator 的 startNext() 方法。这次已经存在可以用于缓存的数据了。所以cacheData()方法将会被触发：

private void cacheData(Object dataToCache) {
    long startTime = LogTime.getLogTime();
    try {
      Encoder encoder = helper.getSourceEncoder(dataToCache);
      DataCacheWriter writer =
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
      originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
      //DiskLrucache保存图片
      helper.getDiskCache().put(originalKey, writer);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Finished encoding source to cache"
            + ", key: " + originalKey
            + ", data: " + dataToCache
            + ", encoder: " + encoder
            + ", duration: " + LogTime.getElapsedMillis(startTime));
      }
    } finally {
      loadData.fetcher.cleanup();
    }

    sourceCacheGenerator =
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
  }
 
 
这里通过DiskCache对象，实际上是DiskLruCacheWrapper实现类对象在磁盘缓存图片。
 
 
小结
 磁盘缓存是在EngineJob中的DecodeJob任务中完成的，依次通过ResourcesCacheGenerator、SourceGenerator、DataCacheGenerator来获取缓存数据。ResourcesCacheGenerator获取的是转换过的缓存数据；SourceGenerator获取的是未经转换的原始的缓存数据；DataCacheGenerator是通过网络获取图片数据再按照按照缓存策略的不同去缓存不同的图片到磁盘上。
 
 
到这里，总算写完了整体流程分析。不过一大堆，你基本不太可能记得住，下面就给大家总结一下吧：
 
 
总结（干货）
 
 
Glide缓存分为弱引用+ LruCache+ DiskLruCache，其中读取数据的顺序是：弱引用 > LruCache > DiskLruCache>网络；写入缓存的顺序是：网络 --> DiskLruCache--> LruCache-->弱引用
 
 
内存缓存分为弱引用的和 LruCache ，其中正在使用的图片使用弱引用缓存，暂时不使用的图片用 LruCache缓存，这一点是通过 图片引用计数器（acquired变量）来实现的，详情可以看内存缓存的小结。
 
 
磁盘缓存就是通过DiskLruCache实现的，根据缓存策略的不同会获取到不同类型的缓存图片。它的逻辑是：先从转换后的缓存中取；没有的话再从原始的（没有转换过的）缓存中拿数据；再没有的话就从网络加载图片数据，获取到数据之后，再依次缓存到磁盘和弱引用。
 
 
抛一个问题给大家思考讨论：
 为什么Glide内存缓存要设计2层，弱引用和LruCache？
 
 
 
  
这是一个朋友的理解 用弱引用缓存的资源都是当前活跃资源 activeRource，资源的使用频率比较高，这个时候如果从LruCache取资源，LinkHashmap查找资源的效率不是很高的。所以他会设计一个弱引用来缓存当前活跃资源，来替Lrucache减压。
 
 
 
 
参考：
 Android Glide4.0 源码遨游记（第五集——缓存机制）
 Android Glide4.0 源码遨游记（第四集）
 Glide 系列-3：Glide 缓存的实现原理（4.8.0）
 Glide 系列-2：主流程源码分析（4.8.0）
 [Glide的图片内存优化]
 (https://www.jianshu.com/p/12e318e6414f)
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android 【手撕Glide】--Glide缓存机制)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执...
                        严建设

                        
    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
    
                    
    • 
                    
  • 百善孝为先
                        杜友顺

                        
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                    
  • 2018-07-20
                        韻梅

                        
    念亲爱的好感谢亲爱的每天照顾我们！因为有你我们心里踏实！念儿子的好儿子感谢你昨晚为我们煎手抓饼，让我们感到你满满的爱与幸福:你煎的与外边买的没有区别，也是脆脆的金黄黄的！我也不担心你的温饱问题，因为你能自己做简单的点心啊！儿子已经长大了，妈妈可要享福了咯！儿子加油！只要你敢想敢行动定能会成功的！
    
                    
    • 
                    
  • 2023-07-24
                        DXZHY

                        
    很2023年7月24号星期天，今天呢一早我就去开店，淋完花我就赶去了中心联谊，感谢中心联谊过程当中，他们在唱诵读者上面1.一边流泪，感觉自己的内在灵魂太长，时间没有得到这样了，所以一边唱手一边在流泪，我分不清楚自己是感动了，还是被呼唤的灵魂所能看到，但我就是哭了，泪流满面，我全身细胞在放松，最后我们荣耀完了之后，我打包了一部分回来，我发现我是挺真爱想摸的，然而。那我们商量好之后，他要做出一些违背我
    
                    
    • 
                    
  • 三梦 | 心碎了还是醉了
                        培根不是肉

                        
    今天，让我一起走进彝族火把节。图片发自App“中国彝族火把节之乡·2016布拖民间火把节”在离学校走约一个时辰路程的地方举行，奔着要在如此隆重的节日之中好好欣赏一番的目的，三梦团队一早便和随队的两个孩子整装待发。图片发自App第一部分:吉尔吉呷我万万没有想到，从踏出校门开始，从我牵上那个孩子的手开始，我心的触动就没有停过。图片发自App我以为我这一路会在观察、拍照和思考中度过，但我发现我错了。这个
    
                    
    • 
                    
  • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    
                    
    • 
                    
  • 红手套节 马小媛为中国城市环卫者公益发声：今天我手红
                        疏狂君

                        
    #红手套节#公益活动，线头公益以及同多方资源的共同努力我们邀请到了线头公益大使马小媛马小媛，1993年5月3日出生于江苏省南京市，中国内地新生代女演员。2015年马小媛参演网剧《余罪》，饰演警校校花安嘉璐的闺蜜。2016年马小媛主演系列电影《丽人保镖》中女一号林欢馨，正式出道。此后，马小媛陆续接演了电视剧《警花与警犬2》，在网剧《你美丽李美丽》中担任女主角李美丽。拂晓，当你还在睡梦中时，这座城跟你
    
                    
    • 
                    
  • 《靡色知音》
                        这个人叫安安

                        
    图片发自App他俯下身来的时候乔伊不是没有心猿意马，但是只一瞬，她又巧妙的偏了一下头。她转身欲走，他倒好，一把扯着她的手，顺势往他怀里一带。乔伊没防备的由惯性硬生生撞进他怀里，贴上一块不可撼动的肉墙。她还没有吃疼的喊出声音来，他就把她翻过身去，像警察一样把她反扣在墙壁。她被他扣的死死地，对方一脸玩味和挑衅。乔伊冷冷的说：“放开。”那人也没应声，扬了扬眉毛，把她往墙壁那里一推，加重了力道。乔伊最好和
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • 原画的线稿要怎么画？线稿这个大难题该怎么破？
                        川川_9d43

                        
    想要画好线稿需要具备什么的条件？一、手需要一个灵活且生动的小手手~~能够自如地操控手上的物体，达到随心所欲的地步，这样高深的操纵方式需要很高的熟练度！比如：上厕所，吃饭，洗脸，手指打结等。二、握笔的姿势握笔的姿势很重要，决定了画的线条的流畅度，小编个人感觉应该没有绝对的正确姿势，就是自己的习惯，随心就好，不盲目的学习别人的握笔的姿势，就像以前的一个典故一样——邯郸学步。三、排线练习排线的时候一定要
    
                    
    • 
                    
  • 《错嫁傻王：王妃她又黑化了》南君宥乔洛染（独家小说）精彩TXT阅读
                        海边书楼

                        
    《错嫁傻王：王妃她又黑化了》南君宥乔洛染（独家小说）精彩TXT阅读主角：南君宥乔洛染简介：堂堂21世纪金牌特种兵乔洛染，穿来的第一天，就被人诬陷私通被逼投江。而前来解救她的，正是她的夫婿——智力受损的痴傻王爷南君宥。傻子娶了一个不贞女，全京城都在等着看他们的笑话。殊不知，乔洛染一手医术济天下，一手制毒退万敌。关注微信公众号【花车文学】去回个书號【36】，即可阅读【错嫁傻王：王妃她又黑化了】小说全文
    
                    
    • 
                    
  • 一伊妹妹
                        杨欣仪小朋友

                        
    大姨家的小棉袄就是一伊妹妹。她长得很可爱，小小的脚丫、小小的手。大姨说她很乖，睡醒了也不哭不闹，我一逗她，她就乐。她在床上趴着原地转圈玩，她玩一会儿就睡一会儿。好好玩的小娃娃。
    
                    
    • 
                    
  • Android实现监听事件的方法
                        Amy木婉清

                        
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    
                    
    • 
                    
  • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    
                    
    • 
                    
  • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    
                    
    • 
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    
                    
    • 
                    
  • 我们一起喵喵喵
                        米菲兴哥

                        
    2021-4-16星期五晴天今天忙碌了2件事情，车险和接种疫苗。对比平安的车险，电销的保险是优惠不少，还送电子门锁（不含安装费用），等会儿查核电子门锁的价格。今天在公司接种疫苗，上次公司安排到社区接种，有点心虚，没有去。这次安排到公司的，就接种吧。早晚要接种的，这次安排这么好，上班时间接种疫苗，直接干呢。下次的接种时间已经安排好啦。刚开始还感觉有点怕怕，皮肤消毒过后，就只有凉凉的感觉，护士的手一接
    
                    
    • 
                    
  • app推广一手资源在哪里找？盘点2024年必备的八大app拉新渠道
                        U客直谈APP

                        
    在2024年即将来临之际，还是有许多小伙伴表示不知道app推广一手资源在哪里找，又要从哪里去了解各个资源渠道的不同特性。好消息来啦，本篇文章就将带大家盘点24年必备的八大app拉新渠道，全文干货，拆解分析点评一步到位，还不快快收藏起来~1.app推广一手资源来源：U客直谈U客直谈是一个资源对接平台，专注于为推广人员提供海量丰富的app拉新任务。其具有数量丰富且类型多样的app拉新任务，使得U客直谈
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 2022-03-23
                        13_yD

                        
    下雨天让人心神不宁。走在路上，打着伞。用双手对抗风的力量，不止是风，还有伞本身的野性。一手抓着手机，一手抓着伞，伞柄压在颈上，硌得大脑缺氧。风在转，人在转，伞在转。看不见头顶的天，只看见伞，和骨上的水，一起转。昏天黑地，脚底没有地，只有无边无际的泥潭，散发着腐烂的气息，下面是一具具尸体，学着我们的步伐，行走在空无一人的路上。头发夹在钢铁之间，快乐地尖叫，钢铁尽情地肆虐，鞭打我的灵魂。灵魂被抛尸在荒
    
                    
    • 
                    
  • 2003-7-13-先胜“李一季”-（让左车马-黑列手炮）
                        夏目青樱

                        
    2003-7-13-【虎滩四战之三】先胜“李一季”-（让左车马-黑列手炮）1.炮二平五炮２平５2.马二进三马８进７3.兵三进一炮８进４4.车一进一炮８平７5.相三进一马２进３6.兵七进一车１平２7.炮八平七卒５进１8.车一平四马３进５？9.车四进二炮７平５10.车四平五车２进７？！11.炮五平八卒５进１？12.车五平八马５进４13.炮七平五炮５进５14.相七进五马４进５15.车八平六车９平８16.
    
                    
    • 
                    
  • 【华为OD技术面】 - 考到的Lettcode手撕算法代码真题目录
                        算法大师
华为od算法
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选目录目录题目备注1052.爱生气的书店老板2024-4LCR058.我的日程安排表I技术二面
    
                    
    • 
                    
  • 手机小游戏开发
                        红匣子实力推荐

                        
    随着智能手机的普及，手机小游戏已经成为人们日常生活中不可或缺的一部分。从简单的消除游戏到复杂的策略游戏，手机小游戏为玩家提供了丰富的娱乐体验。本文将为您介绍手机小游戏开发的基本概念、工具和技术。开发-联系电话：13642679953（微信同号）1.游戏类型手机小游戏可以分为多种类型，如益智游戏、休闲游戏、动作游戏、策略游戏等。开发者可以根据自己的兴趣和技能选择合适的游戏类型进行开发。2.开发工具手
    
                    
    • 
                    
  • 心情不好时，去做这四件事
                        绿茵下

                        
    01读书当一个人的智慧不够时，最容易胡思乱想，将自己困住思维的牢笼里。想要开悟，首先要与智者对话，与高人同行，那么与智者对话最经济实惠的方式，莫过于读书了。于时光的静美中，手捧一本高质量的书籍，在书中窥见先贤们的所思所想，仿佛进入了一个平静的世界，让人思绪越来越清晰明了。或许读书不能够马上帮你解决眼前的难题，可日复一日地坚持下去，总能让你内心更加笃定，心灵更加沉静，生出智慧之花。在书中人物不同的经
    
                    
    • 
                                
  • java线程Thread和Runnable区别和联系
                                    zx_code
javajvmthread多线程Runnable
                                    
    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。 
 
模拟窗口买票，第一例子继承thread，代码如下 
 
package thread;

public class ThreadTest {
	
	public static void main(String[] args) {
		
		Thread1 t1 = new Thread1(
    
                                
    • 
                                
  • 【转】JSON与XML的区别比较
                                    丁_新
jsonxml
                                    
    1.定义介绍 
(1).XML定义 
扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 
XML是标
    
                                
    • 
                                
  • c++ 实现五种基础的排序算法
                                    CrazyMizzz
C++c算法
                                    
    #include<iostream>
using namespace std;


//辅助函数，交换两数之值
template<class T>
void mySwap(T &x, T &y){
	T temp = x;
	x = y;
	y = temp;
}

const int size = 10;

//一、用直接插入排
    
                                
    • 
                                
  • 我的软件
                                    麦田的设计者
我的软件音乐类娱乐放松
                                    
         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
    
                                
    • 
                                
  • linux awk命令详解
                                    被触发
linux awk
                                    
    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 
awk处理过程: 依次对每一行进行处理，然后输出 
awk命令形式: 
awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file 
 [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
    
                                
    • 
                                
  • 各种语言比较
                                    _wy_
编程语言
                                    
                           Java Ruby PHP   擅长领域                      
    
                                
    • 
                                
  • oracle 中数据类型为clob的编辑
                                    知了ing
oracle clob
                                    
    public void updateKpiStatus(String kpiStatus,String taskId){
	Connection dbc=null;
	Statement stmt=null;
	PreparedStatement ps=null;
	try {
		dbc = new DBConn().getNewConnection();
		//stmt = db
    
                                
    • 
                                
  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据
                                    矮蛋蛋
zookeeper
                                    
    原文地址： 
http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 
安装和配置详解 
本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
    
                                
    • 
                                
  • tomcat数据源
                                    alafqq
tomcat
                                    
    数据库 
 
 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。 
 
 
 没有使用JNDI时我用要这样连接数据库： 
 
 
03.  Class.forName("com.mysql.jdbc.Driver");  
04.  conn
    
                                
    • 
                                
  • 遍历的方法
                                    百合不是茶
遍历
                                    
                                                          遍历 
在java的泛
    
                                
    • 
                                
  • linux查看硬件信息的命令
                                    bijian1013
linux
                                    
    linux查看硬件信息的命令 
一.查看CPU： 
cat /proc/cpuinfo 
  
二.查看内存： 
free 
  
三.查看硬盘： 
df 
  
linux下查看硬件信息 
1、lspci 列出所有PCI 设备； 
lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
    
                                
    • 
                                
  • java常见的ClassNotFoundException
                                    bijian1013
java
                                    
    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
    
                                
    • 
                                
  • 【Gson五】日期对象的序列化和反序列化
                                    bit1129
反序列化
                                    
    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题： 
  
1. 序列化时，Date对象序列化的字符串日期格式如何 
2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 
3. Date A -> str -> Date B,A和B对象是否equals 
  默认序列化和反序列化 
  
  
import com
    
                                
    • 
                                
  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream
                                    bit1129
Stream
                                    
      1. DStream的类说明文档： 
  
/**
 * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous
 * sequence of RDDs (of the same type) representing a continuous st
    
                                
    • 
                                
  • 通过nginx获取header信息
                                    ronin47
nginx header
                                    
    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， 
  if ( $http_cookie ~* "(.*)$") { 
          set $all_cookie $1; 
  } 
      变量$all_cookie就获得了cookie的值，可以用于运算了 
 

    
                                
    • 
                                
  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
                                    bylijinnan
java
                                    
    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 
写了个java版的： 
 
 



public class Print_1_To_NDigit {

	/**
	 * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
	 * 1.使用字符串
    
                                
    • 
                                
  • Netty源码学习-ReplayingDecoder
                                    bylijinnan
javanetty
                                    
    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 
 
http://bylijinnan.iteye.com/blog/1982618 
 
API说，ReplayingDecoder简化了操作，比如： 
 
FrameDecoder在decode时，需要判断数据是否接收完全： 
 
 

public class IntegerH
    
                                
    • 
                                
  • js特殊字符过滤
                                    cngolon
js特殊字符js特殊字符过滤
                                    
    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
    
                                
    • 
                                
  • hibernate使用sql查询
                                    ctrain
Hibernate
                                    
    
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.Hibernate;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transa
    
                                
    • 
                                
  • linux shell脚本中切换用户执行命令方法
                                    daizj
linuxshell命令切换用户
                                    
    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下： 
  
1、执行单个命令：su - user -c "command" 
如：下面命令是以test用户在/data目录下创建test123目录 
[root@slave19 /data]# su - test -c "mkdir /data/test123" 
    
                                
    • 
                                
  • 好的代码里只要一个 return 语句
                                    dcj3sjt126com
return
                                    
    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
    
                                
    • 
                                
  • Android动画效果学习
                                    dcj3sjt126com
android
                                    
    1、透明动画效果 
方法一：代码实现 
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
		{
			View rootView = inflater.inflate(R.layout.fragment_main, container, fals
    
                                
    • 
                                
  • linux复习笔记之bash shell (4)管道命令
                                    eksliang
linux管道命令汇总linux管道命令linux常用管道命令
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2105461   
  bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。 
    上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？ 
    答：非常的经典的一句话，记住了，何为管
    
                                
    • 
                                
  • Android系统中自定义按键的短按、双击、长按事件
                                    gqdy365
android
                                    
    在项目中碰到这样的问题： 
由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 
1、单击事件：就是普通key的单击； 
2、双击事件：500ms内同一按键单击两次； 
3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 
4、组合按键：两个以上按键同时按住； 
    
                                
    • 
                                
  • asp.net获取站点根目录下子目录的名称
                                    hvt
.netC#asp.nethovertreeWeb Forms
                                    
    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： 
<asp:ListBox runat="server" ID="lbKeleyiFolder" /> 
  
那么在页面上显示根目录子文件夹的代码如下： 
string[] m_sub
    
                                
    • 
                                
  • Eclipse程序员要掌握的常用快捷键
                                    justjavac
javaeclipse快捷键ide
                                    
       判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。       曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。     写道   程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
    
                                
    • 
                                
  • c++编程随记
                                    lx.asymmetric
C++笔记
                                    
     为了字体更好看，改变了格式…… 
  
&&运算符： 
  
#include<iostream> 
using namespace std; 
int main(){ 
     int a=-1,b=4,k; 
     k=(++a<0)&&!(b--
    
                                
    • 
                                
  • linux标准IO缓冲机制研究
                                    音频数据
linux
                                    
    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
    
                                
    • 
                                
  • 随想 生活
                                    暗黑小菠萝
生活
                                    
    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。 
  
毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
    
                                
    • 
                                
  • 我认为POJO是一个错误的概念
                                    windshome
javaPOJO编程J2EE设计
                                    
      
            这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。 
   &
    
                                
    •