花神子
花神子

02 初识缓存-GuavaCache

在上篇文章01 初识缓存-了解缓存中简单了介绍了下缓存的历程以及几种常见的技术进行简单介绍，本着学习的目的本节针对GuavaCache进行一个专题介绍，可能理解有限欢迎指正。

一 简介

Guava Cache，是Google 出品的 Java 核心增强库的缓存部分，一种非常优秀本地缓存解决方案，提供了基于容量，时间和引用的缓存回收方式。guava cache可以按照多种策略来清理存储在其中的缓存值且保持很高的并发读写性能。基于容量的方式内部实现采用LRU算法，基于引用回收很好的利用了Java虚拟机的垃圾回收机制。其中的缓存构造器CacheBuilder采用构建者模式提供了设置好各种参数的缓存对象，缓存核心类LocalCache里面的内部类Segment与jdk1.7及以前的ConcurrentHashMap非常相似，都继承于ReetrantLock，还有六个队列，以实现丰富的本地缓存方案。

二 GuavaCache使用

2.1 缓存加载器 CacheLoader

CacheLoader是GuavaCache提供的一种加载缓存的机制，可以通过指定的键值进行计算/加载需要进行匹配的缓存数据。GuavaCache虽然提供了这种方式，但是它并不要求编程者一定需要遵循它这种方案，也可以根据自定的实际需求来定制自己加载逻辑。根据GuavaCache提出的如果想复写其缓存的加载方式，但是仍要保留“get-if-absent-compute”语义，GuavaCache在进行缓存获取的时候提供了一种解决方案：可以在调用get方法时传入一个Callable实例，来达到目的。缓存的对象可以通过Cache.put直接插入，但是自动加载是首选，因为自动加载可以更加容易的判断所有缓存信息的一致性。

Guava Cache针对开发者提供了非常友好的编程方式，使用非常简单:

下面例子分别从不同的角度:

From a CacheLoader

LoadingCache 缓存是通过一个CacheLoader来构建缓存。创建一个CacheLoader仅需要实现V load(K key) throws Exception方法即可。通过方法get(K)可以对LoadingCache进行查询。该方法要不返回已缓存的值，要不通过CacheLoader来自动加载相应的值到缓存中。

From a Callable

所有类型的Guava Cache，不论是否会自动加载，都支持get(K, Callable(V))方法。当给定键的缓存值已存在时则直接返回，否则通过指定的Callable方法进行计算并将值存放到缓存中。直到加载完成时，相应的缓存才会被更改。该方法简单实现了"if cached, return; otherwise create, cache and return"（"如果有缓存则返回；否则运算、缓存、然后返回"）语义。

Cache.put

使用cache.put(key, value)方法可以直接向缓存中插入值，这会直接覆盖掉给定键之前映射的值。使用Cache.asMap()视图提供的任何方法也能修改缓存。但请注意，asMap视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说，asMap视图的原子运算在Guava Cache的原子加载范畴之外，所以相比于Cache.asMap().putIfAbsent(K,V)，Cache.get(K, Callable) 应该总是优先使用。

/**
 * @author mzw
 * @version V1.0.0
 * @description
 * @data 2019-05-29 14:53
 * @see
 **/
public class GuavaCache {

    private static final Logger LOGGER = LoggerFactory.getLogger(GuavaCache.class);

    public static void main(String[] args) throws ExecutionException {

        //构建缓存加载器
        CacheLoader loader = new CacheLoader() {
            @Override
            public String load(String key) {
                LOGGER.info(key + " is loaded from a cacheLoader!");
                return key;
            }
        };
        //构建移除监听器：非必要
        RemovalListener removalListener =
                removal -> LOGGER.info("[" + removal.getKey() + ":" + removal.getValue() + "] is evicted!");

        //构建缓存
        LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(4)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .removalListener(removalListener)
                .build(loader);

        //直接放入数据
        for (int i = 0; i < 3; i++) {
            cache.put("key" + i, "value" + i);
        }
        //获取数据
        LOGGER.info("key2  > " + cache.getIfPresent("key2"));
        LOGGER.info("key  > " + cache.getIfPresent("key"));
        //From a CacheLoade
        LOGGER.info("key  > " + cache.get("key"));
        //From a Callable
        LOGGER.info("key  > " + cache.get("k1", () -> "dd"));
    }
}

输出结果

17:36:12.084 [main] INFO com.maozw.quartz.cache.GuavaCache - key2  > value2
17:36:12.086 [main] INFO com.maozw.quartz.cache.GuavaCache - key  > null
17:36:12.090 [main] INFO com.maozw.quartz.cache.GuavaCache - key is loaded from a cacheLoader!
17:36:12.092 [main] INFO com.maozw.quartz.cache.GuavaCache - key  > key
17:36:12.094 [main] INFO com.maozw.quartz.cache.GuavaCache - [key0:value0] is evicted!
17:36:12.094 [main] INFO com.maozw.quartz.cache.GuavaCache - k1  > dd

2.1 缓存回收

guava中数据的移除分为被动移除和主动移除两种，
被动移除数据的方式，简介中曾说过guava cache可以按照多种策略来清理存储在其中的缓存值且保持很高的并发读写性能。基于容量的方式内部实现采用LRU算法，基于引用回收很好的利用了Java虚拟机的垃圾回收机制。Guava Cache提供了三种基本的缓存回收方式:

基于缓存容量大小的移除

当缓存中的元素数量超过指定值时，会把不常用的键值对从cache中移除。

  • 缓存容量大小指的是cache中的条目数；

  • 并不是完全到了缓存容量大小才开始移除不常用的数据的，而是接近缓存容量大小的时候系统就会开始做移除的动作；

  • 如果一个键值对已经从缓存中被移除了，你再次请求访问的时候，如果cachebuild是使用cacheloader方式的，那依然还是会从cacheloader中再取一次值，如果还没有，就会抛出异常。

LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(4)//缓存容量大小
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .removalListener(removalListener)
                .build(loader);

基于缓存时间的移除

guava提供了两个基于时间移除的方法

  • expireAfterAccess(long, TimeUnit)：这个方法是根据某个键值对最后一次访问之后多少时间后移除。缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。

  • expireAfterWrite(long, TimeUnit)：这个方法是根据某个键值对被创建或值被替换后多少时间移除。缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的.

LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(4)//缓存容量大小
                .expireAfterWrite(10, TimeUnit.MINUTES)//缓存时间
                .removalListener(removalListener)
                .build(loader);

基于引用回收（Reference-based Eviction）

这种移除方式主要是基于java的垃圾回收机制，根据键或者值的引用关系决定移除

  • CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。

  • CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。

  • CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。

主动移除数据方式

主动移除有三种方法：

  • 单独缓存项移除 Cache.invalidate(key)

  • 批量缓存项移除 Cache.invalidateAll(keys)

  • 清除所有缓存项 Cache.invalidateAll()

移除监听器

通过CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener会获取移除通知[RemovalNotification]，其中包含移除原因[RemovalCause]、键和值。如果需要改成异步形式，可以考虑使用RemovalListeners.asynchronous(RemovalListener, Executor) 。

缓存储移除的时机

Guava cache中通过CacheBuilder构建的缓存数据不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，它会在读/写操作后同步进行清理工作，只是读操作时可能执行的机会会少少一些。
原因：如果自动清理缓存，就必须存在一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样CacheBuilder就不可用了。

同时用户可以自主的去控制清除时机，比如固定的时间间隔调用Cache.cleanUp()。

2.2 刷新

刷新和回收不太一样。正如LoadingCache.refresh(K)所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃。

重载CacheLoader.reload(K, V)可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。
示例如下：

/**
 * @author mzw
 * @version V1.0.0
 * @description
 * @data 2019-05-29 14:53
 * @see
 **/
public class GuavaCacheDemo {

    private static final Logger LOGGER = LoggerFactory.getLogger(GuavaCacheDemo.class);
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //构建移除监听器：非必要
        RemovalListener removalListener =
                removal -> LOGGER.info("[" + removal.getKey() + ":" + removal.getValue() + "] is evicted!");

        //构建缓存
        LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(5)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .removalListener(removalListener)
                .build(new CacheLoader() {
                    @Override
                    public String load(String s) {
                        return s + " -> load";
                    }

                    @Override
                    public ListenableFuture reload(String key, String oldValue) {
                        LOGGER.info(key + "  > reload : " + oldValue);
                        ListenableFutureTask reloadTask = ListenableFutureTask.create(() -> oldValue + " -> reload");
                        Executors.newFixedThreadPool(1).submit(reloadTask);
                        return reloadTask;
                    }
                });

        //放入数据
        for (int i = 0; i < 3; i++) {
            cache.put("key" + i, "value" + i);
        }
        //获取数据
        LOGGER.info("key  > " + cache.getIfPresent("key"));
        LOGGER.info("key1  > " + cache.getIfPresent("key1"));
        cache.refresh("key1");
        LOGGER.info("refresh : k  > " + cache.get("key1"));

    }
}

输出结果

19:32:01.069 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - key  > null
19:32:01.071 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - key1  > value1
19:32:01.077 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - k  > aa
19:32:01.077 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - key1  > reload : value1
19:32:01.085 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - [key1:value1] is evicted!
19:32:01.086 [main] INFO com.maozw.quartz.cache.GuavaCacheDemo - refresh : k  > value1 -> reload

统计

简单介绍
CacheBuilder.recordStats()：用来开启Guava Cache的统计功能。统计打开后，Cache.stats()方法会返回CacheS tats 对象以提供如下统计信息：
hitRate()：缓存命中率；
averageLoadPenalty()：加载新值的平均时间，单位为纳秒；
evictionCount()：缓存项被回收的总数，不包括显式清除。

三 Guava Cache 解读

在解读之前，先提一下Guava Cache的一些组件：
Guava Cache组件中核心的类和接口列举如下：
接口：

  • Cache 顶级接口，定义get、put、invalidate等操作，以及获取缓存统计数据的方法等。
  • LoadingCache 继承自Cache，并另外提供了一些当get数据不存在时自动去load相关key(s)所对应的value(s)的契约（即接口中的抽象方法），具体实现见LoadingCache的具体实现类。
  • RemovalListener 监听器接口，在缓存被移除的时候用来做一些操作，与下面的RemovalNotification、RemovalCause配套使用。很明显这是个观察者模式的应用。
  • Weigher 权重的接口，提供int weigh(K key, V value)抽象方法，给缓存中的Entry赋予权重信息。

抽象类：

  • AbstractCache 本身是抽象类，实现自Cache接口，基本没做什么实际的工作，大多数方法的实现只是简单抛出UnsupportedOperationException.该抽象类提供了Cache接口的骨架，为了避免子类直接继承Cache接口时必须实现所有抽象方法，这种手法在其他地方也很常见，个人觉得都算得上是一种设计模式了。
  • AbstractLoadingCache 继承自AbstractCache并实现了LoadingCache接口，目的也是提供一个骨架，其中的某些方法提供了在get不到数据时会自动Load数据的契约。
  • CacheLoader 抽象类，最核心的方法就是load，封装load数据的操作，具体如何laod与该抽象类的具体子类有关，只需要重写laod方法，就可以在get不到数据时自动去load数据到缓存中。
  • ForwardingCache 装饰器模式的用法，所有对缓存的操作都委托给其他的实现了Cache接口的类，该抽象类中有一个抽象方法protected abstract Cache delegate();不难推测出来，其他的方法中均使用了该代理。即类似get(key){delegate().get(key)}
  • ForwardingLoadingCache 自行推断，不解释。

实现类：

  • CacheBuilder 建造者模式的应用，缓存构建器。构建缓存的入口，指定缓存配置参数并初始化本地缓存。通过该类来组装Cache，最后调用build方法来生成Cache的实例。
  • CacheBuilderSpec 用来构建CacheBuilder的实例，其中提供了一些配置参数，用这些配置的参数来通过CacheBuilder实例最终构建Cache实例。
  • CacheStats 缓存使用情况统计信息，比如命中多少次，缺失多少次等等。
  • LocalCache 本地缓存最核心的类，Cache接口实例的代理人，Cache接口提供的一些方法内部均采委托给LocalCache实例来实现，LocalCache的具体实现类似于ConcurrentHashMap,也采用了分段的方式。

CacheBuilder

CacheBuilder是缓存配置和构建入口。

在上面例子中我们构建缓存使用如下方式：现在解析CacheBuilder这个建造者的结构

LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(4)//缓存容量大小
                .expireAfterWrite(10, TimeUnit.MINUTES)//缓存时间
                .removalListener(removalListener)
                .build(loader);

整个类内容太长，分段进行解说：

CacheBuilder 属性

  • DEFAULT_INITIAL_CAPACITY：//缓存的默认初始化大小；

  • DEFAULT_CONCURRENCY_LEVEL：LocalCache默认并发数，用来评估Segment的个数；

  • DEFAULT_EXPIRATION_NANOS：//默认的缓存过期时间；

  • initialCapacity：//初始缓存大小

  • concurrencyLevel：用于计算有并发量

  • maximumSize：cache中最多能存放的缓存entry个数

  • expireAfterWriteNanos：//缓存超时时间（起点：缓存被创建或被修改）

  • expireAfterAccessNanos：//缓存超时时间（起点：缓存被创建或被修改或被访问）

public final class CacheBuilder {
  private static final int DEFAULT_INITIAL_CAPACITY = 16;
  private static final int DEFAULT_CONCURRENCY_LEVEL = 4;
  private static final int DEFAULT_EXPIRATION_NANOS = 0;
  private static final int DEFAULT_REFRESH_NANOS = 0;

  static final Supplier NULL_STATS_COUNTER = Suppliers.ofInstance(
      new StatsCounter() {
        ...//省去无关代码
      });
  static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);

  static final Supplier CACHE_STATS_COUNTER =
      new Supplier() {
    @Override
    public StatsCounter get() {
      return new SimpleStatsCounter();
    }
  };

    ...//省去无关代码

  private static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());

  static final int UNSET_INT = -1;

  boolean strictParsing = true;

  int initialCapacity = UNSET_INT;
  int concurrencyLevel = UNSET_INT;
  long maximumSize = UNSET_INT;
  long maximumWeight = UNSET_INT;
  Weigher weigher;

  Strength keyStrength;//键的引用类型（strong、weak、soft）
  Strength valueStrength;//值的引用类型（strong、weak、soft）

  long expireAfterWriteNanos = UNSET_INT;
  long expireAfterAccessNanos = UNSET_INT;
  long refreshNanos = UNSET_INT;
  //key比较策略 
  Equivalence keyEquivalence;
  Equivalence valueEquivalence;

  RemovalListener removalListener;//元素被移除的监听器
  Ticker ticker;
  //状态计数器，默认为NULL_STATS_COUNTER，即不启动计数功能
  Supplier statsCounterSupplier = NULL_STATS_COUNTER;

    ...
}
 
 
build方法
 
 
CacheBuilder构建缓存有两个方法：
 
 
     
  
  • 构建一个具有数据加载功能的缓存，调用LocalCache构造方法
    •  
  
  • 构建一个没有数据加载功能的缓存，调用LocalCache构造方法，但loader为null
    •  
 
 
 
public  LoadingCache build(
      CacheLoader loader) {
    checkWeightWithWeigher();
    return new LocalCache.LocalLoadingCache(this, loader);
}

public  Cache build() {
    checkWeightWithWeigher();
    checkNonLoadingCache();
    return new LocalCache.LocalManualCache(this);
}

 
 
至此我们就需要先了解一下LocalCache了，因为我们此时调用该类的构造方法LocalCache()和实例方法LocalLoadingCache()/LocalManualCache()
 
 
LocalCache
 
 
LocalCache是guava cache的核心类。
 
 
LocalCache的数据结构与ConcurrentHashMap很相似，都由多个segment组成，且各segment相对独立，互不影响，所以能支持并行操作。每个segment由一个table和若干队列组成。缓存数据存储在table中，其类型为AtomicReferenceArray>，即一个数组，数组中每个元素是一个链表。两个队列分别是writeQueue和accessQueue，用来存储写入的数据和最近访问的数据，当数据过期，需要刷新整体缓存（见上述示例最后一次cache.getIfPresent("key5")）时，遍历队列，如果数据过期，则从table中删除。
 
 
LocalCache 数据结构
 
 
Segment[] segments;
 
 
Segment继承于ReetrantLock，减小锁粒度，提高并发效率。
 
 
AtomicReferenceArray> table;
 
 
类似于HasmMap中的table一样，相当于entry的容器。
 
 
ReferenceEntry referenceEntry;
 
 
基于引用的Entry,其实现类有弱引用Entry,强引用Entry等
 
 
ReferenceQueue keyReferenceQueue;
 
 
已经被GC，需要内部清理的键引用队列。
 
 
ReferenceQueue valueReferenceQueue;
 
 
已经被GC，需要内部清理的值引用队列。
 
 
Queue> recencyQueue;
 
 
记录升级可访问列表清单时的entries,当segment上达到临界值或发生写操作时该队列会被清空。
 
 
Queue> writeQueue;
 
 
按照写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部。
 
 
Queue> accessQueue;
 
 
按照访问时间进行排序的元素队列，访问(包括写入)一个元素时会把它加入到队列尾部
 
 
LocalCache 构造器
 
 
构造器是通过CacheBuilder的方法对变量进行初始化。具体变量解说可参照CacheBuilder 属性解说。
 
 
  /**
   * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
   */
  LocalCache(
      CacheBuilder builder, @Nullable CacheLoader loader) {
    concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
    //默认为强引用
    keyStrength = builder.getKeyStrength();
    valueStrength = builder.getValueStrength();

    keyEquivalence = builder.getKeyEquivalence();
    valueEquivalence = builder.getValueEquivalence();

    maxWeight = builder.getMaximumWeight();
    weigher = builder.getWeigher();
    expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
    expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
    refreshNanos = builder.getRefreshNanos();

    removalListener = builder.getRemovalListener();
    removalNotificationQueue = (removalListener == NullListener.INSTANCE)
        ? LocalCache.>discardingQueue()
        : new ConcurrentLinkedQueue>();

    ticker = builder.getTicker(recordsTime());
    entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
    globalStatsCounter = builder.getStatsCounterSupplier().get();
    defaultLoader = loader;

    int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
    if (evictsBySize() && !customWeigher()) {
      initialCapacity = Math.min(initialCapacity, (int) maxWeight);
    }
     ...
    int segmentShift = 0;
    int segmentCount = 1;
    while (segmentCount < concurrencyLevel
           && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
      ++segmentShift;
      segmentCount <<= 1;
    }
    this.segmentShift = 32 - segmentShift;
    segmentMask = segmentCount - 1;
    //初始化segments大小
    this.segments = newSegmentArray(segmentCount);

    int segmentCapacity = initialCapacity / segmentCount;
    if (segmentCapacity * segmentCount < initialCapacity) {
      ++segmentCapacity;
    }

    int segmentSize = 1;
    while (segmentSize < segmentCapacity) {
      segmentSize <<= 1;
    }
    //初始化Segments
    if (evictsBySize()) {
      // Ensure sum of segment max weights = overall max weights
      long maxSegmentWeight = maxWeight / segmentCount + 1;
      long remainder = maxWeight % segmentCount;
      for (int i = 0; i < this.segments.length; ++i) {
        if (i == remainder) {
          maxSegmentWeight--;
        }
        this.segments[i] =
            createSegment(segmentSize, maxSegmentWeight, builder.getStatsCounterSupplier().get());
      }
    } else {
      for (int i = 0; i < this.segments.length; ++i) {
        this.segments[i] =
            createSegment(segmentSize, UNSET_INT, builder.getStatsCounterSupplier().get());
      }
    }
  }

 
 
Segment初始化操作
 
 
初始化容器
 
 
Segment(LocalCache map, int initialCapacity, long maxSegmentWeight,
        StatsCounter statsCounter) {
      this.map = map;
      this.maxSegmentWeight = maxSegmentWeight;
      this.statsCounter = checkNotNull(statsCounter);
      initTable(newEntryArray(initialCapacity));//初始化table

      keyReferenceQueue = map.usesKeyReferences()
           ? new ReferenceQueue() : null;//key引用队列

      valueReferenceQueue = map.usesValueReferences()
           ? new ReferenceQueue() : null;//value引用队列

      recencyQueue = map.usesAccessQueue()
          ? new ConcurrentLinkedQueue>()
          : LocalCache.>discardingQueue();

      writeQueue = map.usesWriteQueue()
          ? new WriteQueue()
          : LocalCache.>discardingQueue();//写入元素队列

      accessQueue = map.usesAccessQueue()
          ? new AccessQueue()
          : LocalCache.>discardingQueue();//访问元素队列
}

 
 
以上是整个初始化流程
 
 
 
 
LocalCache put加载缓存
 
 
Cache 接口声明
 
 
@Beta
@GwtCompatible
public interface Cache {
   void put(K key, V value);
}

 
 
LocalCache的实现
 
 
     
  
  • 内部调用segmentFor(int hash)方法，该方法返回指定的散列hash键值匹配的段。
    •  
  
  • 然后调用Segment的put方法
    •  
 
 
 
@GwtCompatible(emulated = true)
class LocalCache extends AbstractMap implements ConcurrentMap {
@Override
  public V put(K key, V value) {
    checkNotNull(key);
    checkNotNull(value);
    int hash = hash(key);
    return segmentFor(hash).put(key, hash, value, false);
  }
}

 
 
segmentFor(hash).put(key, hash, value, false)
 
 
下面第四行代码可以看出preWriteCleanup在每次put之前都会清理动作，我在缓存储移除的时机小段中进行过提示，缓存的清除时机是在读/写操作的时候进行的。
 
 
@Nullable
V put(K key, int hash, V value, boolean onlyIfAbsent) {
  lock();
  try {
    long now = map.ticker.read();
    preWriteCleanup(now);

    int newCount = this.count + 1;//localCache的Count+1
    if (newCount > this.threshold) { // ensure capacity 是否要进行扩容
      expand();//扩容
      newCount = this.count + 1;
    }
    //获取当前Entry中的HashTable的Entry数组
    AtomicReferenceArray> table = this.table;
    int index = hash & (table.length() - 1);//计算散列值对应table的索引位置
    ReferenceEntry first = table.get(index);//通过索引获取ReferenceEntry

    // Look for an existing entry.进行遍历 如果找到则进行下面逻辑
    for (ReferenceEntry e = first; e != null; e = e.getNext()) {
      K entryKey = e.getKey();
      if (e.getHash() == hash && entryKey != null
          && map.keyEquivalence.equivalent(key, entryKey)) {
        // We found an existing entry.如果找到则进行下面逻辑
        // 对应的值引用
        ValueReference valueReference = e.getValueReference();
        V entryValue = valueReference.get();//获取值
        // cache 提供基于引用的回收策略，此处可能为null：即可能会GC了
        if (entryValue == null) {
          ++modCount;
          if (valueReference.isActive()) {
            enqueueNotification(key, hash, valueReference, RemovalCause.COLLECTED);
            setValue(e, key, value, now);//存储数据，并且将新增加的元素写入两个队列中
            newCount = this.count; // count remains unchanged
          } else {
            setValue(e, key, value, now);
            newCount = this.count + 1;
          }
          this.count = newCount; // write-volatile
          evictEntries();//淘汰缓存
          return null;
        } else if (onlyIfAbsent) {
          // Mimic
          // "if (!map.containsKey(key)) ...
          // else return map.get(key);
          recordLockedRead(e, now);
          return entryValue;
        } else {
          // clobber existing entry, count remains unchanged
          // 如果存在且值不为null 则进行更新value
          ++modCount;
          enqueueNotification(key, hash, valueReference, RemovalCause.REPLACED);
          setValue(e, key, value, now);
          evictEntries();
          return entryValue;
        }
      }
    }

    // Create a new entry. 不存在则新创建newEntry
    ++modCount;
    ReferenceEntry newEntry = newEntry(key, hash, first);
    setValue(newEntry, key, value, now);
    table.set(index, newEntry);
    newCount = this.count + 1;
    this.count = newCount; // write-volatile
    evictEntries();
    return null;
  } finally {
    unlock();
    postWriteCleanup();
  }
}

 
 
LocalCache preWriteCleanup(now);
 
 
简单解说下preWriteCleanup(now);preWriteCleanup在每次put之前都会清理动作
 
 
     
  
  • 通过下面代码的调用链：清理的是keyReferenceQueue和valueReferenceQueue这两个队列，这两个队列是引用队列，Guava Cache为了支持弱引用和软引用，引入了引用清空队列.
    •  
  
  • expireEntries(now) 基于过期时间的清除方式
    •  
 
 
 
@GuardedBy("this")
void preWriteCleanup(long now) {
  runLockedCleanup(now);
}

void runLockedCleanup(long now) {
  if (tryLock()) {
    try {
      drainReferenceQueues();
      expireEntries(now); // calls drainRecencyQueue
      readCount.set(0);
    } finally {
      unlock();
    }
  }
}
//排空键和值引用队列，清除包含垃圾收集的键或值的内部条目
@GuardedBy("this")
void drainReferenceQueues() {
  if (map.usesKeyReferences()) {
    drainKeyReferenceQueue();
  }
  if (map.usesValueReferences()) {
    drainValueReferenceQueue();
  }
}
//基于过期时间的清除
@GuardedBy("this")
void expireEntries(long now) {
  drainRecencyQueue();

  ReferenceEntry e;
  while ((e = writeQueue.peek()) != null && map.isExpired(e, now)) {
    if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
      throw new AssertionError();
    }
  }
  while ((e = accessQueue.peek()) != null && map.isExpired(e, now)) {
    if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
      throw new AssertionError();
    }
  }
}

 
 
drainKeyReferenceQueue
 下面就是清理过程：
 
 
@GuardedBy("this")
void drainKeyReferenceQueue() {
  Reference ref;
  int i = 0;
  while ((ref = keyReferenceQueue.poll()) != null) {
    @SuppressWarnings("unchecked")
    ReferenceEntry entry = (ReferenceEntry) ref;
    map.reclaimKey(entry);
    if (++i == DRAIN_MAX) {
      break;
    }
  }
}

void reclaimKey(ReferenceEntry entry) {
    int hash = entry.getHash();
    segmentFor(hash).reclaimKey(entry, hash);
}

/**
 * Removes an entry whose key has been garbage collected.
 */
boolean reclaimKey(ReferenceEntry entry, int hash) {
  lock();
  try {
    int newCount = count - 1;
    AtomicReferenceArray> table = this.table;
    int index = hash & (table.length() - 1);
    ReferenceEntry first = table.get(index);

    for (ReferenceEntry e = first; e != null; e = e.getNext()) {
      if (e == entry) {
        ++modCount;
        ReferenceEntry newFirst = removeValueFromChain(
            first, e, e.getKey(), hash, e.getValueReference(), RemovalCause.COLLECTED);
        newCount = this.count - 1;
        table.set(index, newFirst);
        this.count = newCount; // write-volatile
        return true;
      }
    }

    return false;
  } finally {
    unlock();
    postWriteCleanup();
  }
}

 
 
LocalCache get获取缓存值
 
 
Cache 接口声明
 
 
@Beta
@GwtCompatible
public interface Cache {
   V get(K key) throws ExecutionException;
}

 
 
LocalLoadingCache的实现
 
 
下面是get方法的调用链：最终执行segmentFor(hash).get(key, hash, loader);
 
 
     
  
  • 首先通过key 与 散列值获取Entry，如果获取Entry不为null；继续获取对应的value；如果value不为null，并更新访问时间，加入recencyQueue，之后进行判断是否进行刷新逻辑 返回。
    •  
  
  • 如果value为null，检测是否进行loading，如果是则等待，等待结果waitForLoadingValue(e, key, valueReference);；
    •  
  
  • 如果获取Entry为null，则lockedGetOrLoad(key, hash, loader); ，其方法逻辑实现与put方法非常相似，这里就不在做介绍。有兴趣的读者可以去看看。也需要说明的时候，此时该方法相当有就是写缓存，所以也会进行加锁。
    •  
 
 
 
@Override
public V get(K key) throws ExecutionException {
  return localCache.getOrLoad(key);
}

V getOrLoad(K key) throws ExecutionException {
  return get(key, defaultLoader); 
}

V get(K key, CacheLoader loader) throws ExecutionException {
  int hash = hash(checkNotNull(key));
  return segmentFor(hash).get(key, hash, loader);
}

V get(K key, int hash, CacheLoader loader) throws ExecutionException {
  checkNotNull(key);
  checkNotNull(loader);
  try {
    if (count != 0) { // read-volatile volatile读会刷新缓存，尽量保证可见性,如果为0那么直接load
      // don't call getLiveEntry, which would ignore loading values
      ReferenceEntry e = getEntry(key, hash);
      if (e != null) {//判断通过key与hash获取的Entry是否为null，不为null则存在
        long now = map.ticker.read();//获取当前的访问时间
        V value = getLiveValue(e, now);//根据当前访问时间获取Live的数据
        if (value != null) {
          recordRead(e, now);//设置entry的AccessTime。并且加入recencyQueue
          statsCounter.recordHits(1);//记录缓存命中
          return scheduleRefresh(e, key, hash, value, now, loader)// 如果定时刷新,尝试刷新value
        }
        //value为null,如果此时value正在刷新，那么此时等待刷新结果
        ValueReference valueReference = e.getValueReference();
        if (valueReference.isLoading()) {
          return waitForLoadingValue(e, key, valueReference);
        }
      }
    }

    // at this point e is either null or expired;
    return lockedGetOrLoad(key, hash, loader);
  } catch (ExecutionException ee) {
    Throwable cause = ee.getCause();
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    } else if (cause instanceof RuntimeException) {
      throw new UncheckedExecutionException(cause);
    }
    throw ee;
  } finally {
    postReadCleanup();//每次Put和get之后都要进行一次Clean
  }
}

 
 
至此针对 Guava Cache的使用，以及它的运转流程做了一个简单的介绍。可能水平有限如果有不正确的地方请指正。
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(02 初识缓存-GuavaCache)

        

            

                
    
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 本周第二次约练
                        2cfbdfe28a51

                        
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    
                    
    • 
                    
  • 今日联对0306
                        诗图佳得

                        
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
    
                    
    • 
                    
  • 2022-07-08
                        保利学府里李楚怡1307022

                        
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    
                    
    • 
                    
  • 2022-04-18
                        Apbenz

                        
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
    
                    
    • 
                    
  • 每日一题——第八十二题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
    
                    
    • 
                    
  • 每日一题——第八十三题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 2020.11.19
                        隆非凡

                        
    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
    
                    
    • 
                    
  • 2018/02/12
                        Tracy_zhang

                        
    人生并不在于获取，更在于放得下。放下一粒种子，收获一棵大树;放下一处烦恼，收获一个惊喜;放下一种偏见，收获一种幸福;放下一种执著，收获一种自在。放下既是一种理性抉择，也是一种豁达美。只要看得开放得下，何愁没有快乐的春莺在啼鸣，何愁没有快乐的泉溪在歌唱，何愁没有快乐的鲜花绽放!
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 2023-04-17|篮球女孩
                        长一木

                        
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 春季养肝正当时
                        dxn悟

                        
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
    
                    
    • 
                    
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    
                    
    • 
                    
  • 2023-10-22
                        奥雷里亚诺第n

                        
    昨天在B站看到关于猫喜欢挠人的视频，视频教导说猫挠人的话就抓住它的后脖颈然后用手打打挠人的那个爪子。视频本身没什么，但评论区却炸开了锅（真是符合挑食者厌食心理）。令我印象最深刻的一个甚至上升到了关于我是谁这种终极问题。它说，猫就是畜生，它挠人就打它别惯着它，反正我六道轮回成了人就应该保持人的高贵，谁都别想来打破。我顿时汗颜，但看到下面全是类似的言论只不过后面的理由各有不同，本来想骂人的心都凉了一半
    
                    
    • 
                    
  • 2022-11-17
                        无奇君

                        
    又去了一次社康，这次是急性支气管炎……太难了。半夜就猛咳，天天咳醒，还好他戴海绵耳塞睡吵不到他，要不然对他来说也是种煎熬。一累也会猛咳，希望这次是最后一次吃药，吃完就好。又想把头发剪短了，顺便染个色。可是刚刚去看人家还没开门，不是休息日老板好佛系。理发店是个夫妻店，一年多前刚搬来的时候老板还没对象呢，当时聊天老板就说希望能找个对象一起两个人守着店都比上班强。不久后再去他已经有对象了，而且在店里帮忙
    
                    
    • 
                    
  • 冬天短期的暴利小生意有哪些？那些小生意适合新手做？
                        一起高省

                        
    短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
    
                    
    • 
                    
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    
                    
    • 
                    
  • 2020-12-16
                        长寿富贵

                        
    9：56不知今天哪位亲来说说话呀？成萌：尽尽皆是道。道道皆相同。不解呀？成萌：郁郁不得志，混混过日子。哦……说谁的呀？成萌：说自己呀……还能说谁呢？那如何办呢？成萌：回头……如何回头？成萌：回见心源。如何回见心源？成萌：不追不随诸相迁，如如不动在心田。啊？成萌：慢慢守心吧。
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？
                        高省APP大九

                        
    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • 直返APP是什么?直返APP是干嘛的
                        氧惠帮朋友一起省

                        
    直返是一种电商购物模式，其核心特点是用户购买商品后可以获得直接返利。具体来说，用户在直返电商平台购买商品时，不仅可以获得商品本身的优惠，还可以获得一定的现金返利或者积分奖励。返利的金额可以提现到用户的账户余额，或者用于下次购物时抵扣。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万
    
                    
    • 
                    
  • 直返的东西正品吗?直返APP安全吗?直返是正规平台吗?
                        氧惠购物达人

                        
    亲们，你们是不是经常在直返APP上买东西呀？但是，你们有没有想过，里面的东西到底是不是正品呢？这个APP安全吗？它是不是一个正规的平台呀？别着急，今天我就来给大家揭秘一下！氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大
    
                    
    • 
                                
  • HttpClient 4.3与4.3版本以下版本比较
                                    spjich
javahttpclient
                                    
    网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。 
httpclient又可分为 
 
 httpclient3.x 
 httpclient4.x到httpclient4.3以下 
 httpclient4.3
    
                                
    • 
                                
  • Essential Studio Enterprise Edition 2015 v1新功能体验
                                    Axiba
.net
                                    
    概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！ 
syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
    
                                
    • 
                                
  • [宇宙与天文]微波背景辐射值与地球温度
                                    comsci
背景
                                    
     
 
 
        宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢? 
 
     如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢? 
 
 
  &nbs
    
                                
    • 
                                
  • lvs-server
                                    男人50
server
                                    
    #!/bin/bash 
# 
# LVS script for VS/DR 
# 
#./etc/rc.d/init.d/functions 
# 
VIP=10.10.6.252 
RIP1=10.10.6.101 
RIP2=10.10.6.13 
PORT=80 
case $1 in 
start) 
 
  /sbin/ifconfig eth2:0 $VIP broadca
    
                                
    • 
                                
  • java的WebCollector爬虫框架
                                    oloz
爬虫
                                    
    WebCollector主页： 
https://github.com/CrawlScript/WebCollector 
 
下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。 
 
接下来看demo 
package org.spider.myspider;

import cn.edu.hfut.dmic.webcollector.cra
    
                                
    • 
                                
  • jQuery append 与 after 的区别
                                    小猪猪08

                                    
    1、after函数 
定义和用法： 
after() 方法在被选元素后插入指定的内容。 
语法： 
$(selector).after(content) 
实例： 
<html> 
<head> 
<script type="text/javascript" src="/jquery/jquery.js"></scr
    
                                
    • 
                                
  • mysql知识充电
                                    香水浓
mysql
                                    
    索引  
索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。 
 
根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。 
 
大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关； 
 
MYISAM和InnoDB存储引擎
    
                                
    • 
                                
  • 我的架构经验系列文章索引
                                    agevs
架构
                                    
    下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。 
要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。 
（内容是前几天写的，现附上索引） 
  
 
 前端架构 http://www.
    
                                
    • 
                                
  • Android so lib库远程http下载和动态注册
                                    aijuans
andorid
                                    
    一、背景 
  
   在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。 
  
二、主要
    
                                
    • 
                                
  • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法
                                    baalwolf
option
                                    
    在客户端访问subversion版本库时出现这个错误： 
svnserve.conf:12: Option expected 
为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
    
                                
    • 
                                
  • MongoDB的连接池和连接管理
                                    BigCat2013
mongodb
                                    
    在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。 
通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
    
                                
    • 
                                
  • AngularJS使用Socket.IO
                                    bijian1013
JavaScriptAngularJSSocket.IO
                                    
            目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。 
        Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
    
                                
    • 
                                
  • [Maven学习笔记四]Maven依赖特性
                                    bit1129
maven
                                    
    三个模块 
为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和user-service 
  
依赖作用范围 
 Maven的dependency定义
    
                                
    • 
                                
  • 【Akka一】Akka入门
                                    bit1129
akka
                                    
    什么是Akka 
Message-Driven Runtime is the Foundation to Reactive Applications 
In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
    
                                
    • 
                                
  • zabbix_api之perl语言写法
                                    ronin47
zabbix_api之perl
                                    
    zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example:   #!/usr/bin/perl 
 
 use 5.010 ; 
 use strict ; 
 use warnings ; 
 use JSON :: RPC :: Client ; 
 use 
    
                                
    • 
                                
  • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！
                                    brotherlamp
linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学
                                    
    比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！ 
  
----------------------------------------------------- 
兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1 
链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65 
  
兄弟连Lin
    
                                
    • 
                                
  • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(
                                    bylijinnan
java
                                    
    
import java.util.Random;

/**
 * 题目：
 * 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)，
 * 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
    
                                
    • 
                                
  • map的三种遍历方法
                                    chicony
map
                                    
      
package com.test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestMap {
    public static v
    
                                
    • 
                                
  • Linux安装mysql的一些坑
                                    chenchao051
linux
                                    
    1、mysql不建议在root用户下运行 
  
2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf)  
chown -R cc /etc/init.d/mysql
    
                                
    • 
                                
  • Sublime Text 3 配置
                                    daizj
配置Sublime Text
                                    
    Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
    
                                
    • 
                                
  • MySQL server has gone away 问题的解决方法
                                    dcj3sjt126com
SQL Server
                                    
    MySQL server has gone away 问题解决方法，需要的朋友可以参考下。 
应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
    
                                
    • 
                                
  • javascript/dom:固定居中效果
                                    dcj3sjt126com
JavaScript
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&
    
                                
    • 
                                
  • 使用 Spring 2.5 注释驱动的 IoC 功能
                                    e200702084
springbean配置管理IOCOffice
                                    
    使用 Spring 2.5 注释驱动的 IoC 功能 
 developerWorks 
 
 
文档选项 
 将打印机的版面设置成横向打印模式 
 
打印本页 
 将此页作为电子邮件发送 
 
将此页作为电子邮件发送 
 
级别： 初级 
 
陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司 
 
2008 年 2 月 28 日 
 
 &nb
    
                                
    • 
                                
  • MongoDB常用操作命令
                                    geeksun
mongodb
                                    
    1.   基本操作 
db.AddUser(username,password)               添加用户 
db.auth(usrename,password)      设置数据库连接验证 
db.cloneDataBase(fromhost)     
    
                                
    • 
                                
  • php写守护进程（Daemon）
                                    hongtoushizi
PHP
                                    
    转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655 
  
守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。 
  
1、基本概念 
  &nbs
    
                                
    • 
                                
  • spring整合mybatis,关于注入Dao对象出错问题
                                    jonsvien
DAOspringbeanmybatisprototype
                                    
    今天在公司测试功能时发现一问题： 
先进行代码说明： 
1，controller配置了Scope="prototype"（表明每一次请求都是原子型） 
   @resource/@autowired service对象都可以（两种注解都可以）。 
2，service 配置了Scope="prototype"（表明每一次请求都是原子型） 

    
                                
    • 
                                
  • 对象关系行为模式之标识映射
                                    home198979
PHP架构企业应用对象关系标识映射
                                    
    HELLO!架构 
  
一、概念 
identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。 
  
  
二、为什么要使用标识映射？ 
在数据源架构模式之数据映射器中 
//c
    
                                
    • 
                                
  • Linux下hosts文件详解
                                    pda158
linux
                                    
    　1、主机名：   　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。   　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。   　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
    
                                
    • 
                                
  • nginx配置文件粗解
                                    spjich
javanginx
                                    
    #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
    
                                
    • 
                                
  • 数学函数
                                    w54653520
java
                                    
    public  
class  
S {       
     
// 传入两个整数，进行比较，返回两个数中的最大值的方法。   
     
public  
int  
get( 
int  
num1, 
int  
nu
    
                                
    •