tracy_668
tracy_668

guava cache 源码之get put

在上一篇文章中介绍了guava cache是怎么构造的，接下来cache中两个重要的方法，put、get，我们先来看看put方法：

@Override
    public void put(K key, V value) {
      localCache.put(key, value);
    }
  /**
   * 代理到Segment的put方法
   * @param key
   * @param value
   * @return
   */
  @Override
  public V put(K key, V value) {
    checkNotNull(key);
    checkNotNull(value);
    int hash = hash(key);
    return segmentFor(hash).put(key, hash, value, false);
  }

@Nullable
    V put(K key, int hash, V value, boolean onlyIfAbsent) {
      //保证线程安全，加锁
      lock();
      try {
        //获取当前的时间
        long now = map.ticker.read();
        //清除队列中的元素
        preWriteCleanup(now);
        //localCache的Count+1
        int newCount = this.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);
        //获取第一个元素
        ReferenceEntry first = table.get(index);
        //遍历整个Entry链表
        // 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();
            //获取value
            V entryValue = valueReference.get();
            //如果entry的value为null，可能被GC掉了
            if (entryValue == null) {
              ++modCount;
              if (valueReference.isActive()) {
                enqueueNotification( //减小锁时间的开销
                    key, hash, entryValue, valueReference.getWeight(), RemovalCause.COLLECTED);
                //利用原来的key并且刷新value
                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(e);
              return null;
            } else if (onlyIfAbsent) {//原来的Entry中包含指定key的元素，所以读取一次，读取操作需要更新Access队列
              // Mimic
              // "if (!map.containsKey(key)) ...
              // else return map.get(key);
              recordLockedRead(e, now);
              return entryValue;
            } else {
              //如果value不为null,那么更新value
              // clobber existing entry, count remains unchanged
              ++modCount;
              //将replace的Cause添加到队列中
              enqueueNotification(
                  key, hash, entryValue, valueReference.getWeight(), RemovalCause.REPLACED);
              setValue(e, key, value, now);//存储数据，并且将新增加的元素写入两个队列中
              //数据的淘汰
              evictEntries(e);
              return entryValue;
            }
          }
        }
        //如果目标的entry不存在，那么新建entry
        // Create a new entry.
        ++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
        //淘汰多余的entry
        evictEntries(newEntry);
        return null;
      } finally {
        //解锁
        unlock();
        //处理刚刚的remove Cause
        postWriteCleanup();
      }
    }

说明

  • put方法一开始就加锁是为了保证线程安全，这点和ConcurrentHashMap一致
  • preWriteCleanup在每次put之前都会清理动作，清理啥呢？
@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 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;
        }
      }
    }

清理的是keyReferenceQueue和valueReferenceQueue这两个队列，这两个队列是引用队列，Guava Cache为了支持弱引用和软引用，引入了引用清空队列，同时将key和value包装成了KeyReference 和 ValueReference,在构造cache缓存器一文中我们知道在创建Entry的时候有：

@GuardedBy("this")
    ReferenceEntry newEntry(K key, int hash, @Nullable ReferenceEntry next) {
      return map.entryFactory.newEntry(this, checkNotNull(key), hash, next);
    }

利用map.entryFactory创建Entry。Factory的初始化是通过

entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());

可选的工厂有：

static final EntryFactory[] factories = {
      STRONG,
      STRONG_ACCESS,
      STRONG_WRITE,
      STRONG_ACCESS_WRITE,
      WEAK,
      WEAK_ACCESS,
      WEAK_WRITE,
      WEAK_ACCESS_WRITE,
    };

通过相应的工厂创建对应的Entry，这里主要说一下WeakEntry:

WEAK {
      @Override
       ReferenceEntry newEntry(
          Segment segment, K key, int hash, @Nullable ReferenceEntry next) {
        return new WeakEntry(segment.keyReferenceQueue, key, hash, next);
      }
    },

/**
   * Used for weakly-referenced keys.
   */
  static class WeakEntry extends WeakReference implements ReferenceEntry {
    WeakEntry(ReferenceQueue queue, K key, int hash, @Nullable ReferenceEntry next) {
      super(key, queue);
      this.hash = hash;
      this.next = next;
    }

    @Override
    public K getKey() {
      return get();
    }

    /*
     * It'd be nice to get these for free from AbstractReferenceEntry, but we're already extending
     * WeakReference.
     */

    // null access

    @Override
    public long getAccessTime() {
      throw new UnsupportedOperationException();
    }

WeakEntry继承了WeakReference实现了ReferenceEntry，也就是说这个引用是弱引用。WeakEntry引用的key和Value随时可能会被回收。构造的时候参数里面有ReferenceQueue queue，这个就是我们上面提到的KeyReferenceQueue,所以在Key被GC掉的时候，会自动的将引用加入到ReferenceQueue这样我们就能处理对应的Entry了。Value也是一样的。 清理KeyReferenceQueue的过程：

@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().get(),
                    e.getValueReference(),
                    RemovalCause.COLLECTED);
            newCount = this.count - 1;
            table.set(index, newFirst);
            this.count = newCount; // write-volatile
            return true;
          }
        }

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

上面就是清理过程了，如果发现key或者value被GC了，那么会在put的时候触发清理。

接下来是setvalue方法了，它做的是将value写入Entry

 /**
     * Sets a new value of an entry. Adds newly created entries at the end of the access queue.
     */
    @GuardedBy("Segment.this")
    void setValue(ReferenceEntry entry, K key, V value, long now) {
      ValueReference previous = entry.getValueReference();
      int weight = map.weigher.weigh(key, value);
      checkState(weight >= 0, "Weights must be non-negative");

      ValueReference valueReference =
          map.valueStrength.referenceValue(this, entry, value, weight);
      entry.setValueReference(valueReference);
      recordWrite(entry, weight, now);
      previous.notifyNewValue(value);
    }

    /**
     * Updates eviction metadata that {@code entry} was just written. This currently amounts to
     * adding {@code entry} to relevant eviction lists.
     */
    @GuardedBy("Segment.this")
    void recordWrite(ReferenceEntry entry, int weight, long now) {
      // we are already under lock, so drain the recency queue immediately
      drainRecencyQueue();
      totalWeight += weight;

      if (map.recordsAccess()) {
        entry.setAccessTime(now);
      }
      if (map.recordsWrite()) {
        entry.setWriteTime(now);
      }
      accessQueue.add(entry);
      writeQueue.add(entry);
    }

GuavaCache会维护两个队列，一个Write队列、一个Access队列，用这两个队列来实现最近读和最近写的清楚操作，来看看AccessQueue的实现：

 /**
   * A custom queue for managing access order. Note that this is tightly integrated with
   * {@code ReferenceEntry}, upon which it reliese to perform its linking.
   *
   * 
Note that this entire implementation makes the assumption that all elements which are in
   * the map are also in this queue, and that all elements not in the queue are not in the map.
   *
   * 
The benefits of creating our own queue are that (1) we can replace elements in the middle
   * of the queue as part of copyWriteEntry, and (2) the contains method is highly optimized
   * for the current model.
   */
  static final class AccessQueue extends AbstractQueue> {
    final ReferenceEntry head = new AbstractReferenceEntry() {

      @Override
      public long getAccessTime() {
        return Long.MAX_VALUE;
      }

      @Override
      public void setAccessTime(long time) {}

      ReferenceEntry nextAccess = this;

      @Override
      public ReferenceEntry getNextInAccessQueue() {
        return nextAccess;
      }

      @Override
      public void setNextInAccessQueue(ReferenceEntry next) {
        this.nextAccess = next;
      }

      ReferenceEntry previousAccess = this;

      @Override
      public ReferenceEntry getPreviousInAccessQueue() {
        return previousAccess;
      }

      @Override
      public void setPreviousInAccessQueue(ReferenceEntry previous) {
        this.previousAccess = previous;
      }
    };

    // implements Queue

    @Override
    public boolean offer(ReferenceEntry entry) {
      // unlink
      connectAccessOrder(entry.getPreviousInAccessQueue(), entry.getNextInAccessQueue());

      // add to tail
      connectAccessOrder(head.getPreviousInAccessQueue(), entry);
      connectAccessOrder(entry, head);

      return true;
    }

    @Override
    public ReferenceEntry peek() {
      ReferenceEntry next = head.getNextInAccessQueue();
      return (next == head) ? null : next;
    }

    @Override
    public ReferenceEntry poll() {
      ReferenceEntry next = head.getNextInAccessQueue();
      if (next == head) {
        return null;
      }

      remove(next);
      return next;
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean remove(Object o) {
      ReferenceEntry e = (ReferenceEntry) o;
      ReferenceEntry previous = e.getPreviousInAccessQueue();
      ReferenceEntry next = e.getNextInAccessQueue();
      connectAccessOrder(previous, next);
      nullifyAccessOrder(e);

      return next != NullEntry.INSTANCE;
    }

重点看下offer方法做了啥：
1.将Entry和它的前节点后节点的关联断开，这样就需要Entry中维护它的前向和后向引用。
2.将新增加的节点加入到队列的尾部，寻找尾节点用了head.getPreviousInAccessQueue()。可以看出来是个环形队列。
3.将新增加的节点，或者新调整出来的节点设为尾部节点。

可以得知，最近更新的节点一定是在尾部的，head后面的节点一定是不活跃的，在每一次清除过期节点的时候一定清除head之后的超时的节点。

接下来看看evictEntry，当Cache中设置了缓存最大条目前提下可能会触发：

/**
     * Performs eviction if the segment is full. This should only be called prior to adding a new
     * entry and increasing {@code count}.
     */
    @GuardedBy("Segment.this")
    void evictEntries() {
      if (!map.evictsBySize()) {
        return;
      }

      drainRecencyQueue();
      while (totalWeight > maxSegmentWeight) {
        ReferenceEntry e = getNextEvictable();
        if (!removeEntry(e, e.getHash(), RemovalCause.SIZE)) {
          throw new AssertionError();
        }
      }
    }

先判断是否开启淘汰，之后清理ReferenceQueue，然后判断是否超过权重，超过的话就清理最近最少使用的Entry。

最后再看看在finall执行的postWriteCleanup，回调相应的listener方法。

 void processPendingNotifications() {
    RemovalNotification notification;
    while ((notification = removalNotificationQueue.poll()) != null) {
      try {
        removalListener.onRemoval(notification);
      } catch (Throwable e) {
        logger.log(Level.WARNING, "Exception thrown by removal listener", e);
      }
    }
  }

get 方法源码

get 流程：

  1. 获取对象引用（引用可能是非alive的，比如是需要失效的、比如是loading的）；
  2. 判断对象引用是否是alive的（如果entry是非法的、部分回收的、loading状态、需要失效的，则认为不是alive）。
  3. 如果对象是alive的，如果设置refresh，则异步刷新查询value，然后等待返回最新value。
  4. 针对不是alive的，但却是在loading的，等待loading完成（阻塞等待）。
  5. 这里如果value还没有拿到，则查询loader方法获取对应的值（阻塞获取）。
// LoadingCache methods
    //local cache的代理
    @Override
    public V get(K key) throws ExecutionException {
      return localCache.getOrLoad(key);
    }

      /**
   * 根据key获取value,如果获取不到进行load
   * @param key
   * @return
   * @throws ExecutionException
     */
  V getOrLoad(K key) throws ExecutionException {
    return get(key, defaultLoader);
  }

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

  // loading
    //进行指定key对应的value的获取，读取不加锁
    V get(K key, int hash, CacheLoader loader) throws ExecutionException {
      //保证key-value不为null
      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);
          //如果对应的Entry不为Null,证明值还在
          if (e != null) {
            long now = map.ticker.read();//获取当前的时间，根据当前的时间进行Live的数据的读取
            V value = getLiveValue(e, now);  //  判断是否为alive（此处是懒失效，在每次get时才检查是否达到失效时机）
            //元素不为null的话可以不刷新
            if (value != null) {
              recordRead(e, now);//为entry增加accessTime,同时加入recencyQueue
              statsCounter.recordHits(1);//更新当前的状态，增加为命中,可以用于计算命中率
              // 如果指定了定时刷新 就尝试刷新value
              return scheduleRefresh(e, key, hash, value, now, loader);
            }
            //value为null,如果此时value正在刷新，那么此时等待刷新结果
            ValueReference valueReference = e.getValueReference();
            if (valueReference.isLoading()) {
// 如果正在加载的，等待加载完成后，返回加载的值。（阻塞，future的get)
              return waitForLoadingValue(e, key, valueReference);
            }
          }
        }
        //如果取不到值，那么进行统一的加锁get
        // at this point e is either null or expired;     此处或者为null，或者已经被失效。
        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
      }
    }

get的实现和JDK1.6的ConcurrentHashMap思想一致，都是put加锁，但是get是用volatile保证。这里主要做了：

  1. 首先获取Entry，Entry不为null获取对应的Value，如果Value不为空，那么证明值还在，那么这时候判断一下是否要刷新直接返回了。否则判断目前引用是否在Loading，如果是就等待Loading结束。
  2. 如果取不到Entry或者Value为null 并且没有在Loading，那么这时候进行lockedGetOrLoad(),这是一个大活儿。
V lockedGetOrLoad(K key, int hash, CacheLoader loader) throws ExecutionException {
      ReferenceEntry e;
      ValueReference valueReference = null;
      LoadingValueReference loadingValueReference = null;
      boolean createNewEntry = true;

      lock();//加锁，因为会改变数据结构
      try {
        // re-read ticker once inside the lock
        long now = map.ticker.read();
        preWriteCleanup(now);//清除引用队列,Acess队列和Write队列中过期的数据,这算是一次put操作

        int newCount = this.count - 1;
        AtomicReferenceArray> table = this.table;
        int index = hash & (table.length() - 1);
        ReferenceEntry first = table.get(index);
        //定位目标元素
        for (e = first; e != null; e = e.getNext()) {
          K entryKey = e.getKey();
          if (e.getHash() == hash
              && entryKey != null
              && map.keyEquivalence.equivalent(key, entryKey)) {
            valueReference = e.getValueReference();
            //如果目前处在loading状态，不创建新元素
            if (valueReference.isLoading()) {
              createNewEntry = false;
            } else {
              V value = valueReference.get();
              if (value == null) { //可能被GC掉了，加入removeListener
                enqueueNotification(
                    entryKey, hash, value, valueReference.getWeight(), RemovalCause.COLLECTED);
              } else if (map.isExpired(e, now)) { //可能过期了
                // This is a duplicate check, as preWriteCleanup already purged expired
                // entries, but let's accomodate an incorrect expiration queue.
                enqueueNotification(
                    entryKey, hash, value, valueReference.getWeight(), RemovalCause.EXPIRED);
              } else {//目前就已经加载过了，返回
                recordLockedRead(e, now);
                statsCounter.recordHits(1);
                // we were concurrent with loading; don't consider refresh
                return value;
              }
              //删除在队列中相应的引用，因为后面要新创建
              // immediately reuse invalid entries
              writeQueue.remove(e);
              accessQueue.remove(e);
              this.count = newCount; // write-volatile
            }
            break;
          }
        }
        //创建新的Entry,但是此时是没有值的
        if (createNewEntry) {
          loadingValueReference = new LoadingValueReference();

          if (e == null) {
            e = newEntry(key, hash, first);
            e.setValueReference(loadingValueReference);
            table.set(index, e);
          } else {
        // 到此，说e找到，但是是非法的，数据已被移除。e放入新建的引用
            e.setValueReference(loadingValueReference);
          }
        }
      } finally {
        unlock();
        postWriteCleanup();
      }
 // 上面加锁部分建完了新的entry，设置完valueReference（isAlive为false，isLoading 为false），到此，锁已经被释放，其他线程可以拿到一个loading状态的引用。这就符合get时，拿到loading状态引用后，阻塞等待加载的逻辑了。
      if (createNewEntry) {
        try {
          // Synchronizes on the entry to allow failing fast when a recursive load is
          // detected. This may be circumvented when an entry is copied, but will fail fast most
          // of the time.
      // 这里只对e加锁，而不是segment，允许get操作进入。
          synchronized (e) {
            return loadSync(key, hash, loadingValueReference, loader);
          }
        } finally {
          statsCounter.recordMisses(1);
        }
      } else {
        // The entry already exists. Wait for loading.
        return waitForLoadingValue(e, key, valueReference);
      }
    }

说明：

  • load算是一个写操作，需要加锁，
  • 为了避免缓存被击穿，每个线程都去load容易导致数据库雪崩

因为是写所以要进行preWriteCleanup，根据key定位一下Entry，如果能定位到，那么判断是否在Loading，如果是的话不创建新的Entry并且等待Loading结束。如果不是那么判断value是否为null和是否过期，如果是的话都要进行创建新Entry，如果都不是证明value是加载过了，那么更新下Access队列然后返回，

// at most one of loadSync/loadAsync may be called for any given LoadingValueReference
    //同步刷新
    V loadSync(
        K key,
        int hash,
        LoadingValueReference loadingValueReference,
        CacheLoader loader)
        throws ExecutionException {
      ListenableFuture loadingFuture = loadingValueReference.loadFuture(key, loader);
      return getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
    }

这里创建了一个loadingReference，这也就是之前看到的判断是否在Loading。如果是Loading状态那么表明有一个线程正在更新Cache，其他的线程等待就可以了。

从上面我们可以看到，对于每一次get都会去进行Access队列的更新，同时对于多线程的更新只会引起一个线程去load数据，对于不存在的数据，get时也会进行一次load操作。同时通过同步操作解决了缓存击穿的问题。

这里讲下引用队列(Reference Queue)

  • 引用队列可以很容易地实现跟踪不需要的引用。
  • 一旦弱引用对象开始返回null，该弱引用指向的对象就被标记成了垃圾。
  • 当你在构造WeakReference时传入一个ReferenceQueue对象，当该引用指向的对象被标记为垃圾的时候，这个引用对象会自动地加入到引用队列里面。

ReferenceEntry

  • Cache中的所有Entry都是基于ReferenceEntry的实现。
  • 信息包括：自身hash值，写入时间，读取时间。每次写入和读取的队列。以及链表指针。
  • 每个Entry中均包含一个ValueReference类型来表示值。

ValueReference的类图

  • 对于ValueReference，有三个实现类：StrongValueReference、SoftValueReference、WeakValueReference。为了支持动态加载机制，它还有一个LoadingValueReference，在需要动态加载一个key的值时，先把该值封装在LoadingValueReference中，以表达该key对应的值已经在加载了，如果其他线程也要查询该key对应的值，就能得到该引用，并且等待改值加载完成，从而保证该值只被加载一次（可以在evict以后重新加载）。在该值加载完成后，将LoadingValueReference替换成其他ValueReference类型。

  • 每个ValueReference都纪录了weight值，所谓weight从字面上理解是“该值的重量”，它由Weighter接口计算而得。

  • 还定义了Stength枚举类型作为ValueReference的factory类，它有三个枚举值：Strong、Soft、Weak，这三个枚举值分别创建各自的ValueReference。

WeakEntry为例子

在cache的put操作和带CacheBuilder中的都有newEntry的操作。newEntry根据cache builder的配置生成不用级别的引用，比如put操作：

// Create a new entry.
++modCount;
// 新建一个entry
ReferenceEntry newEntry = newEntry(key, hash, first);
// 设置值，也就是valueRerence
setValue(newEntry, key, value, now);

newEntry方法
根据cache创建时的配置（代码中生成的工厂），生成不同的Entry。

ReferenceEntry newEntry(K key, int hash, @Nullable ReferenceEntry next) {
  return map.entryFactory.newEntry(this, checkNotNull(key), hash, next);
}

调用WEAK的newEntry，其中segment.keyReferenceQueue是key的引用队列。还有一个value的引用队列，valueReferenceQueue一会会出现。

WEAK {
  @Override
   ReferenceEntry newEntry(
      Segment segment, K key, int hash, @Nullable ReferenceEntry next) {
    return new WeakEntry(segment.keyReferenceQueue, key, hash, next);
  }
},

setValue方法
首先要生成一个valueReference，然后set到entry中。

ValueReference valueReference =
      map.valueStrength.referenceValue(this, entry, value, weight);
entry.setValueReference(valueReference);

Value的WEAK跟key的WEAK形式很像。只不过，增加了weight值（cachebuilder复写不同k，v对应的权重）和value的比较方法。

WEAK {
  @Override
   ValueReference referenceValue(
      Segment segment, ReferenceEntry entry, V value, int weight) {
    return (weight == 1)
        ? new WeakValueReference(segment.valueReferenceQueue, value, entry)
        : new WeightedWeakValueReference(
            segment.valueReferenceQueue, value, entry, weight);
  }

  @Override
  Equivalence defaultEquivalence() {
    return Equivalence.identity();
  }
};


cache如何基于引用做清理


如果key或者value的引用不是Strong类型，那么它们必然会被gc回收掉。回收掉后，引用对象依然存在，只是值为null了，这也是上文提到从entry中得到的ValueReference要判断的原因了。


**
 * Drain the key and value reference queues, cleaning up internal entries containing garbage
 * collected keys or values.
 */
@GuardedBy("this")
void drainReferenceQueues() {
  if (map.usesKeyReferences()) {
    drainKeyReferenceQueue();
  }
  if (map.usesValueReferences()) {
    drainValueReferenceQueue();
  }
}



如何失效，因为k和v的失效方法基本一样，只举例drainValueReferenceQueue。（执行前都会tryLock，执行时保证有锁）


void drainValueReferenceQueue() {
  Reference ref;
  int i = 0;
  while ((ref = valueReferenceQueue.poll()) != null) {
    @SuppressWarnings("unchecked")
    ValueReference valueReference = (ValueReference) ref;
    // 回收
    map.reclaimValue(valueReference);
    if (++i == DRAIN_MAX) {
      break;
    }
  }
}



如何回收呢?


    

  1. map是segment维护的cache的引用，再次hash到segment。
    2. 

  2. 找到segment后，加锁，hash找到entry table。遍历链表，根据key找到一个entry。
    3. 

  3. 如果找到，且跟入参的valueReference==比较相等，执行removeValueFromChain
    4. 

  4. 如果没找到，返回false。
    5. 

  5. 如果找到，不等，返回false。
    6. 



removeValueFromChain


ReferenceEntry removeValueFromChain(ReferenceEntry first,
    ReferenceEntry entry, @Nullable K key, int hash, ValueReference valueReference,
    RemovalCause cause) {
  enqueueNotification(key, hash, valueReference, cause);
  writeQueue.remove(entry);
  accessQueue.remove(entry);

  if (valueReference.isLoading()) {
    valueReference.notifyNewValue(null);
    return first;
  } else {
    return removeEntryFromChain(first, entry);
  }
}



    

  1. 需要执行remove的通知，入队列。
    2. 

  2. 针对LoadingValueReference，直接返回。
    3. 

  3. 非loading执行移除。
     具体如何执行remove呢？removeEntryFromChain
    4. 



ReferenceEntry removeEntryFromChain(ReferenceEntry first,
                                          ReferenceEntry entry) {
    int newCount = count;
    ReferenceEntry newFirst = entry.getNext();
    for (ReferenceEntry e = first; e != entry; e = e.getNext()) {
        // 这个方法是copy当前结点（e），然后将新的结点指向newFirst，返回copy得到的结点（next）。
        // 如果改entry是需要回收的，那么该方法返回null。
        ReferenceEntry next = copyEntry(e, newFirst);
        if (next != null) {
            newFirst = next;
        } else {
             // 如果偶遇k或者v已经回收了的entry，进入需要通知的队列。
            removeCollectedEntry(e);
            newCount--;
        }
    }
    this.count = newCount;
    return newFirst;
}



这段逻辑是，从first开始，一直到要remove结点（entry）的next（newFirst），依次copy每个结点，指向newFirst，然后将newFirst变成自身。最后这条链表的头就变成，最后copy的那个结点，也就是entry的上一个结点。


Cache的失效和回调


基于读写时间失效
 失效逻辑和过程：


    

  • Entry在进行一次读写操作后，会标识accessTime和writeTime。
    • 



f (map.recordsAccess()) {
      entry.setAccessTime(now);
  }
  if (map.recordsWrite()) {
      entry.setWriteTime(now);
  }



    

  • accessQueue和writeQueue分别会在读写操作适时的添加。
    • 



  accessQueue.add(entry);
  writeQueue.add(entry);



    

  • 遍历accessQueue和writeQueue
    • 



void expireEntries(long now) {
    drainRecencyQueue();

    ReferenceEntry e;
    // 取出entry，判断是否失效
    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();
      }
    }
  }



    

  • 判断是否失效
    • 



if (expiresAfterAccess()
      && (now - entry.getAccessTime() >= expireAfterAccessNanos)) {
      return true;
  }  



    

  • removeEntry就是调用上文的removeValueFromChain。
    • 



write链（writeQueue）和access链（accessQueue）


这两条链都是一个双向链表，通过ReferenceEntry中的previousInWriteQueue、nextInWriteQueue和previousInAccessQueue、nextInAccessQueue链接而成，但是以Queue的形式表达。


WriteQueue和AccessQueue都是自定义了offer、add（直接调用offer）、remove、poll等操作的逻辑。


    

  • 对于offer（add）操作，如果是新加的节点，则直接加入到该链的队首，如果是已存在的节点，则将该节点链接的链首。（head始终保持在队首，新节点不断插入到队首。逻辑上最先插入的结点保持在，允许访问的头部）
    • 

  • 对remove操作，直接从该链中移除该节点；
    • 

  • 对poll操作，将头节点的下一个节点移除，并返回。
    • 



@Override
public boolean offer(ReferenceEntry entry) {
  // unlink
  connectAccessOrder(entry.getPreviousInAccessQueue(), entry.getNextInAccessQueue());

  // add to tail
  connectAccessOrder(head.getPreviousInAccessQueue(), entry);
  connectAccessOrder(entry, head);

  return true;
}



失效的通知回调


void enqueueNotification(@Nullable K key, int hash, ValueReference valueReference,
                         RemovalCause cause) {
    totalWeight -= valueReference.getWeight();
    if (cause.wasEvicted()) {
        statsCounter.recordEviction();
    }
    if (map.removalNotificationQueue != DISCARDING_QUEUE) {
        V value = valueReference.get();
        RemovalNotification notification = new RemovalNotification(key, value, cause);
        map.removalNotificationQueue.offer(notification);
    }
}



    

  1. 首先判断移除的原因RemovalCause：EXPLICIT（remove、clear等用户有预期的操作），REPLACED（put、replace），COLLECTED，EXPIRED，SIZE。RemovalCause有个方法wasEvicted，表示是否是被驱逐的。前两种是false，后三种是true。
    2. 

  2. 生成一个notification对象，入队列。
    3. 



removalNotificationQueue何时被清理
 在读写操作的finally阶段，都会执行。


 void processPendingNotifications() {
  RemovalNotification notification;
  while ((notification = removalNotificationQueue.poll()) != null) {
    try {
      // 这里就是回调构造cache时注册的listener了
      removalListener.onRemoval(notification);
    } catch (Throwable e) {
      logger.log(Level.WARNING, "Exception thrown by removal listener", e);
    }
  }
}



至此，guava cache的核心源码分析完了，感觉挺恶心的，，挺复杂的，还需要多复习巩固才能真正掌握。
























你可能感兴趣的:(guava cache 源码之get put)






    

  • 扫地机类清洁产品之直流无刷电机控制
悟空胆好小
清洁服务机器人单片机人工智能

    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    

    • 

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    

    • 

  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
小鹿_33

    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    

    • 

  • 《大清方方案》| 第二话
谁佐清欢

    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    

    • 

  • 每日一题——第八十四题
互联网打工人no1
C语言程序设计每日一练c语言

    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
    

    • 

  • 每日一题——第八十二题
互联网打工人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(
    

    • 

  • 《庄子.达生9》
钱江潮369

    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    

    • 

  • Python中os.environ基本介绍及使用方法
鹤冲天Pro
#Pythonpython服务器开发语言

    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    

    • 

  • Goolge earth studio 进阶4——路径修改与平滑
陟彼高冈yu
Googleearthstudio进阶教程旅游

    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

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

    • 

  • 2020-04-12每天三百字之连接与替代
冷眼看潮

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

    • 

  • 东南林氏之九牧林候选父系
祖缘树TheYtree

    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    

    • 

  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景

    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    

    • 

  • 大伟说成语之唉声叹气
求索大伟

    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    

    • 

  • libyuv之linux编译
jaronho
Linuxlinux运维服务器

    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    

    • 

  • 回溯算法-重新安排行程
chirou_
算法数据结构图论c++图搜索

    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    

    • 

  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
高省_飞智666600

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

    • 

  • python os 环境变量
CV矿工
python开发语言numpy

    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    

    • 

  • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    

    • 

  • 锁之缘
尘缘诗词原创作品

    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    

    • 

  • ARM驱动学习之基础小知识
JT灬新一
ARM嵌入式arm开发学习

    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    

    • 

  • ARM驱动学习之5 LEDS驱动
JT灬新一
嵌入式C底层arm开发学习单片机

    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    

    • 

  • ARM驱动学习之4小结
JT灬新一
嵌入式C++arm开发学习linux

    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    

    • 

  • C++ | Leetcode C++题解之第409题最长回文串
Ddddddd_158
经验分享C++Leetcode题解

    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    

    • 

  • 2020-12-24
我和我的天使们

    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
    

    • 

  • 18、架构-可观测性之聚合度量
大树~~
架构javapython后端架构

    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    

    • 

  • 学习“论语”-第59天
春峰轩

    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
    

    • 

  • java数字签名三种方式
知了ing
javajdk

    以下3钟数字签名都是基于jdk7的
1，RSA
String password="test";
// 1.初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(51
    

    • 

  • Hibernate学习笔记
caoyong
Hibernate

    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King
2>、搭建Hibernate的开发环境
     a>、添加jar包:
     aa>、hibernatte开发包中/lib/required/所
    

    • 

  • 设计模式之装饰器模式Decorator（结构型）
漂泊一剑客
Decorator

    1. 概述
       若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
      
    

    • 

  • 读取磁盘文件txt，并输入String
一炮送你回车库
String

    public static void main(String[] args) throws IOException {
 
 String fileContent = readFileContent("d:/aaa.txt");
 
 System.out.println(fileContent);
  

    

    • 

  • js三级联动下拉框
3213213333332132
三级联动

    
//三级联动
省/直辖市<select id="province"></select>
市/省直辖<select id="city"></select>
县/区 <select id="area"></select>

    

    • 

  • erlang之parse_transform编译选项的应用
616050468
parse_transform游戏服务器属性同步abstract_code

             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
    

    • 

  • JAVA JSON的解析
darkranger
java

    
// {
// “Total”：“条数”，
// Code: 1,
//
// “PaymentItems”:[
// {
// “PaymentItemID”:”支款单ID”,
// “PaymentCode”:”支款单编号”,
// “PaymentTime”:”支款日期”,
// ”ContractNo”:”合同号”，
// 
    

    • 

  • POJ-1273-Drainage Ditches
aijuans
ACM_POJ

    POJ-1273-Drainage Ditches
http://poj.org/problem?id=1273
基本的最大流，按LRJ的白书写的
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define INF 0x7fffffff
int ma
    

    • 

  • 工作流Activiti5表的命名及含义
atongyeye
工作流Activiti

    activiti5 - http://activiti.org/designer/update在线插件安装
activiti5一共23张表
Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。
ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。
A
    

    • 

  • android的广播机制和广播的简单使用
百合不是茶
android广播机制广播的注册

          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
    

    • 

  • Spring事务传播行为详解
bijian1013
javaspring事务传播行为

            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。
        Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
    

    • 

  • eidtplus operate
征客丶
eidtplus

    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动
列模式替换或复制内容(多行):
右键-->格式-->填充所选内容-->选择相应操作
OR
Ctrl+Shift+V(复制多行数据,必须行数一致)
-------------------------------------------------------
    

    • 

  • 【Kafka一】Kafka入门
bit1129
kafka

    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧
  下载Kafka
http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz
2.10表示Scala的版本，而0.8.1.1表示Kafka
    

    • 

  • Spring 事务实现机制
BlueSkator
spring代理事务

    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
    

    • 

  • bootstrap源码学习与示例：bootstrap-dropdown（转帖）
BreakingBad
bootstrapdropdown

    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。
一个下拉开菜单的设计：
<ul class="nav pull-right">
<li id="fat-menu" class="dropdown">

    

    • 

  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
/*
* 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
* 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
*
* 在我看来，Mediator模式是把多个对象（
    

    • 

  • 常用代码记录
chenjunt3
UIExcelJ#

     
1、单据设置某行或某字段不能修改
//i是行号,"cash"是字段名称
getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
//取得单据表体所有项用以上语句做循环就能设置整行了
getBillC
    

    • 

  • 搜索引擎与工作流引擎
comsci
算法工作搜索引擎网络应用

     
    最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)
  -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
    

    • 

  • oracle Health Monitor
daizj
oracleHealth Monitor

    About Health Monitor
Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database.
About Health Monitor Checks
Health M
    

    • 

  • JSON字符串转换为对象
dieslrae
javajson

        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
  
    

    • 

  • C语言学习八结构体，综合应用，学生管理系统
dcj3sjt126com
C语言

    实现功能的代码：
# include <stdio.h>
# include <malloc.h>
struct Student
{
int age;
float score;
char name[100];
};
int main(void)
{
int len;
struct Student * pArr;
int i,
    

    • 

  • vagrant学习笔记
dcj3sjt126com
vagrant

    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant
 
1. vagrant virtualbox 下载安装
https://www.vagrantup.com/downloads.html
https://www.virtualbox.org/wiki/Downloads
 
查看安装在命令行输入vagrant
 
 
2.
    

    • 

  • 14.性能优化-优化-软件配置优化
frank1234
软件配置性能优化

    1.Tomcat线程池
修改tomcat的server.xml文件：
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
    

    • 

  • 一个不错的shell 脚本教程 入门级
HarborChung
linuxshell

    一个不错的shell 脚本教程 入门级
建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
    

    • 

  • Spring4新特性——核心容器的其他改进
jinnianshilongnian
spring动态代理spring4依赖注入

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • Linux设置tomcat开机启动
liuxingguome
tomcatlinux开机自启动

    执行命令sudo gedit /etc/init.d/tomcat6
然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。
#!/bin/bash
#
# /etc/rc.d/init.d/tomcat
# init script for tomcat precesses
    

    • 

  • 第13章 Ajax进阶（下）
onestopweb
Ajax

    index.html
<!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/
    

    • 

  • Troubleshooting Crystal Reports off BW
blueoxygen
BO

    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE
 
Quite useful, especially this part:
SAP BW connectivity
For t
    

    • 

  • Java开发熟手该当心的11个错误
tomcat_oracle
javajvm多线程单元测试

    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    

    • 

  • 正则表达式大全
yang852220741
html编程正则表达式

    今天向大家分享正则表达式大全，它可以大提高你的工作效率
正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。
一、校验数字的表达式
数字：^[0-9]*$
n位的数字：^\d{n}$
至少n位的数字：^\d{n,}$
m-n位的数字：^\d{m,n}$
    

    •