柏油
柏油

Guava Cache源码分析

缓存

缓存是高并发场景下提高热点数据访问性能的一个有效手段，在开发项目时会经常使用到。缓存的类型分为：本地缓存、分布式缓存和多级缓存

  • 本地缓存：也就是在进程的内存中进行缓存，比如最简单的Map来实现，也可以使用Guava Cache和Ehcache这样的工具来实现；本地缓存是内存访问，没有远程交互开销，性能最好，但是受限于单机容量，一般缓存较小且无法扩展。
  • 分布式缓存： 一般具有良好的水平扩展能力，可以很好的解决以上问题，对较大数据量的场景也能应付自如。缺点就是需要进行远程请求，性能不如本地缓存
  • 多级缓存：为了平衡本地缓存和分布式缓存的问题，实际业务中一般采用多级缓存，本地缓存只保存访问频率最高的部分热点数据，其他的热点数据放在分布式缓存中

今天聊聊Guava Cache实现的本地缓存

选用Guava Cache

版本

  • 与master分支同步的HEAD-jre-SNAPSHOT版本，据此最近的一个发行版本是14/04/2020发布的29.0-jre

Guava Cache

用Java Map做缓存功能简单，缺乏淘汰策略，缓存统计等信息，使用Guava Cache可以弥补这类问题
  • 提供LRU缓存淘汰策略
    • 清理过期等数据时 一是可以通过另开线程进行维护，二是惰性清理 即 访问时清理，Guava Cache采用的是后者
  • 支持强引用、弱引用和软引用的key/value，及时清理掉key/value被GC的entry
  • 提供CacheStats记录缓存击中率等信息

使用

Guava Cache使用非常方便，通过CacheBuilder定义一个cache并设置相应参数即可

   @Test
   public void test() throws Exception {
       // 创建一个Cache
       //  - 写入数据后10s过期
       //  - 2s刷新一次
       //  - 添加删除Listener，当entry被删除时可以做相关操作
       //  - 定义CacheLoader，当cache中不存在
       Cache cache = CacheBuilder.newBuilder()
               .expireAfterWrite(10, TimeUnit.SECONDS)
               .refreshAfterWrite(2, TimeUnit.SECONDS)
               .removalListener((notification) -> {
                   System.out.println("removed key:" + notification.getKey()
                           + " value:" + notification.getValue());
               })
               .build(new CacheLoader() {
                   @Override
                   public CacheObject load(String key) throws Exception {
                       System.out.println(key + " loaded");
                       CacheObject o = new CacheObject();
                       o.setKey(key);
                       o.setValue(key + ":value:" + Thread.currentThread().getId());
                       return o;
                   }
               });

       CacheObject o1 = cache.get("key1");
       assertNotNull(o1);

       Thread.sleep(3000);

       CacheObject o2 = cache.get("key1");
       assertNotNull(o2);
   }

应用及原理

加载 - 提供两种方式进行加载

  • CacheLoader

    Cache cache = CacheBuilder.newBuilder()
                   .build(new CacheLoader() {
                       @Override
                       public CacheObject load(String key) throws Exception {
                           // load your data
                           return o;
                       }
                   });

  • Callable

      // 如果cache中没有 就根据loader进行加载
  V get(K key, Callable loader)

    两者区别呢， CacheLoader针对全局的key进行load, 而Callable则是指定key, 使用上更为灵活

淘汰策略

  • 通过参数expireAfterAccessNanos访问多久后过期, expireAfterWriteNanos写入多久后过期

    /** Returns true if the entry has expired. */
boolean isExpired(ReferenceEntry entry, long now) {
  checkNotNull(entry);
  // 设置了参数&已过期
  if (expiresAfterAccess() && (now - entry.getAccessTime() >= expireAfterAccessNanos)) {
    return true;
  }
  if (expiresAfterWrite() && (now - entry.getWriteTime() >= expireAfterWriteNanos)) {
    return true;
  }
  return false;
}

  • 根据参数maximumSize最大entry数量，maximumWeight最大占用内存。两者只能设置一个

    // 构造函数中初始化
maxWeight = builder.getMaximumWeight();

long getMaximumWeight() {
  if (expireAfterWriteNanos == 0 || expireAfterAccessNanos == 0) {
    return 0;
  }
  return (weigher == null) ? maximumSize : maximumWeight;
}

// 超过限制则尝试淘汰部分entry
 void evictEntries(ReferenceEntry newest) {
   if (!map.evictsBySize()) {
     return;
   }

   // 将recencyQueue的访问信息维护到LRU队列accessQueue中
   drainRecencyQueue();

   // newest.getValueReference().getWeight()这个值单位既可以是条数也可以是大小, 具体看子类实现
   // 如果这个entry的weight大小已经大于整个段(segment)的最大限制，直接清除掉
   if (newest.getValueReference().getWeight() > maxSegmentWeight) {
     if (!removeEntry(newest, newest.getHash(), RemovalCause.SIZE)) {
       throw new AssertionError();
     }
   }

   // 此Segment中存活的weight总大小 大于segment的最大限制，从LRU队列(accessQueue) 清除，直到满足限制
   while (totalWeight > maxSegmentWeight) {
     ReferenceEntry e = getNextEvictable();
     if (!removeEntry(e, e.getHash(), RemovalCause.SIZE)) {
       throw new AssertionError();
     }
   }
 }

  • 软引用、弱引用回收

     /**
  * Drain the key and value reference queues, cleaning up internal entries containing garbage
  * collected keys or values.
  */
 void drainReferenceQueues() {
 // 首先得使用了软引用or弱引用
   if (map.usesKeyReferences()) {
     // 清除key被GC的entry
     drainKeyReferenceQueue();
   }
   if (map.usesValueReferences()) {
     // 清除value被GC的entry
     drainValueReferenceQueue();
   }
 }
 
 boolean usesKeyReferences() {
   return keyStrength != Strength.STRONG;
 }

 void drainKeyReferenceQueue() {
   Reference ref;
   int i = 0;
   // 如果已经进入了引用队列 那就是被GC了
   while ((ref = keyReferenceQueue.poll()) != null) {
     @SuppressWarnings("unchecked")
     ReferenceEntry entry = (ReferenceEntry) ref;
     // 清除这条entry
     map.reclaimKey(entry);
     if (++i == DRAIN_MAX) {
       break;
     }
   }
 }
 
 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;
     }
   }
 }

手动清除

  • 指定key清除

    /** Discards any cached value for key {@code key}. */
void invalidate(@CompatibleWith("K") Object key);

  • 清除多个key

     /**
  * Discards any cached values for keys {@code keys}.
  *
  * @since 11.0
  */
 void invalidateAll(Iterable keys);

  • 清除所有entry

     /** Discards all entries in the cache. */
 void invalidateAll();

删除监听器

  • 整个cache中每移除一条entry时都会调用一个方法来触发删除监听器

       void enqueueNotification(
       @Nullable K key, int hash, @Nullable V value, int weight, RemovalCause cause) {
     totalWeight -= weight;
     if (cause.wasEvicted()) {
       statsCounter.recordEviction();
     }
     // 如果设置了监听器就将删除信息放在队列中等待 删除监听器处理
     if (map.removalNotificationQueue != DISCARDING_QUEUE) {
       RemovalNotification notification = RemovalNotification.create(key, value, cause);
       map.removalNotificationQueue.offer(notification);
     }
   }

   // get or put都会触发此操作，无须加锁场景
   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);
       }
     }
   }

CacheStats统计信息

  public static final class SimpleStatsCounter implements StatsCounter {
    // 缓存击中次数
    private final LongAddable hitCount = LongAddables.create();
    // 未击中次数
    private final LongAddable missCount = LongAddables.create();
    // 数据加载成功次数
    private final LongAddable loadSuccessCount = LongAddables.create();
    // 加载异常次数
    private final LongAddable loadExceptionCount = LongAddables.create();
    // 总的加载时间
    private final LongAddable totalLoadTime = LongAddables.create();
    // 淘汰次数
    private final LongAddable evictionCount = LongAddables.create();
 }

源码分析

CacheBuilder

使用Cache的入口类, 构造者模式 按需设置参数，常用有两种

  • 不带loader，底层通过LocalCache.LocalManualCache构建

     public  Cache build() {
   checkWeightWithWeigher();
   checkNonLoadingCache();
   return new LocalCache.LocalManualCache<>(this);
 }
 
 其中LocalManualCache定义
 static class LocalManualCache implements Cache, Serializable {
   final LocalCache localCache;

   LocalManualCache(CacheBuilder builder) {
     this(new LocalCache(builder, null));
   }

  • 带loader, 底层通过LocalCache.LoadingCache构建

       public  LoadingCache build(
       CacheLoader loader) {
     checkWeightWithWeigher();
     return new LocalCache.LocalLoadingCache<>(this, loader);
   }
   
   // 其中LocalLoadingCache定义
   static class LocalLoadingCache extends LocalManualCache
       implements LoadingCache {
 
     LocalLoadingCache(
         CacheBuilder builder, CacheLoader loader) {
       super(new LocalCache(builder, checkNotNull(loader)));
     }

    • 这种方式在get(key)的时候，cache中有则返回，否则根据loader进行加载

        public V get(K key) throws ExecutionException {
        return localCache.getOrLoad(key);
      }

LocalCache - 缓存核心实现

LocalCache是Guava Cache缓存的核心实现，整个组建都以它为中心扩展，常用的两个扩展LocalManualCache, LoadingCache

  • LocalCache 从设计上来看

     class LocalCache extends AbstractMap implements ConcurrentMap {

 // 最大容量
 static final int MAXIMUM_CAPACITY = 1 << 30;
 // 最大段数量
 static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
 // 通过contains判断某个值是否存在时，因为在未加锁的情况下，通过多次尝试来判断
 static final int CONTAINS_VALUE_RETRIES = 3;
 // 简单的说就是 在无锁的情况下，读操作达到了这个次数才进行一次清理
 static final int DRAIN_THRESHOLD = 0x3F;
 // 每次清理的最大entry数量(避免一次性清理过多 耗时太长)
 static final int DRAIN_MAX = 16;
 // 这两参数是在根据hash确定具体的segment时用的
 final int segmentMask;
 final int segmentShift;
 // 每个localCache的段信息，所有数据也都在这里
 final Segment[] segments;
 // 并发数，影响段数量(segments)
 final int concurrencyLevel;
 // key/value判等器
 final Equivalence keyEquivalence;
 final Equivalence valueEquivalence;
 // 这俩值确定来key/value的引用类型(强/软/弱)
 final Strength keyStrength;
 final Strength valueStrength;
 // 允许的最大条目数or最大占用内存
 final long maxWeight;
 // 访问后多久过期
 final long expireAfterAccessNanos;
 // 写入后多久过期
 final long expireAfterWriteNanos;
 // 刷新间隔
 final long refreshNanos;
 // entry移除后，等待removalListener处理的队列
 final Queue> removalNotificationQueue;
 // 删除监听器，可做一些删除后处理
 final RemovalListener removalListener;
 // 计时相关的
 final Ticker ticker;
 // Entry创建工厂, 枚举类
 final EntryFactory entryFactory;
 // 统计器
 final StatsCounter globalStatsCounter;
 // 默认加载
 final @Nullable CacheLoader defaultLoader;
 
 .......
 
    设计思路上和JDK1.7 ConcurrentHashMap相似，采用分段锁的思想保证线程安全性，而segments的数量在构造时就已经确定好了，
     因此实际的操作已委托给segment处理了，Segment可以看作HashTable的缩小版(将一个大的Table首次hash分散到不同Segment上，在segment中再次hash将数据分散到不同table上，
     也就是后续的增/删/查/扩容都只和segment有关了)，不同segment之间互不影响，可以并发操作
     
    看看LocalCache和Segment的关联
     
    public @Nullable V get(@Nullable Object key) {
  if (key == null) {
    return null;
  }
  int hash = hash(key);
  // 首次hash找到相关的段
  return segmentFor(hash).get(key, hash);
}

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

public @Nullable V getIfPresent(Object key) {
  int hash = hash(checkNotNull(key));
  V value = segmentFor(hash).get(key, hash);
  if (value == null) {
    globalStatsCounter.recordMisses(1);
  } else {
    globalStatsCounter.recordHits(1);
  }
  return value;
}

Segment segmentFor(int hash) {
   return segments[(hash >>> segmentShift) & segmentMask];
}

     
    来看看LocalCache构造方法
     
     LocalCache(
     CacheBuilder builder, @Nullable CacheLoader loader) {
   // 并发数
   concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
   // key/value引用类型
   keyStrength = builder.getKeyStrength();
   valueStrength = builder.getValueStrength();
   // key/value判等器
   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 = (int) Math.min(initialCapacity, maxWeight);
   }

   int segmentShift = 0;
   int segmentCount = 1;
   // 根据concurrencyLevel将segment数量调成2的指数大小，想想HashMap
   // 在没有指定maxWeight的情况下，segment数量只和concurrencyLevel相关; 否则segment数量至少要满足有20条entry
   while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
     ++segmentShift;
     segmentCount <<= 1;
   }
   this.segmentShift = 32 - segmentShift;
   segmentMask = segmentCount - 1;

   // 创建segments数组并初始化
   this.segments = newSegmentArray(segmentCount);
   // 初始化容量均分到segment上
   int segmentCapacity = initialCapacity / segmentCount;
   if (segmentCapacity * segmentCount < initialCapacity) {
     ++segmentCapacity;
   }

   int segmentSize = 1;
   while (segmentSize < segmentCapacity) {
     segmentSize <<= 1;
   }

   // 如果设置了条目数量(or大小)，需要分配到每个segment上
   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());
     }
   }
 }

     
    OK, LocalCache要做的工作就差不多了，下面看看核心操作Segment，接着上面创建createSegment来看看
     
     Segment createSegment(
     int initialCapacity, long maxSegmentWeight, StatsCounter statsCounter) {
   return new Segment<>(this, initialCapacity, maxSegmentWeight, statsCounter);
 }
 
 Segment(
     LocalCache map,
     int initialCapacity,
     long maxSegmentWeight,
     StatsCounter statsCounter) {
   this.map = map;
   this.maxSegmentWeight = maxSegmentWeight;
   this.statsCounter = checkNotNull(statsCounter);
   initTable(newEntryArray(initialCapacity));

   // key/value引用队列，软/弱引用可用，key or value被GC后的entry都会被放进此队列
   // 之后便可根据此队列清除entry(也就是之前说的 引用回收)
   keyReferenceQueue = map.usesKeyReferences() ? new ReferenceQueue() : null;
   valueReferenceQueue = map.usesValueReferences() ? new ReferenceQueue() : null;

   // 注意这里默认用的支持并发访问的ConcurrentLinkedQueue
   // 本来accessQueue就可以支持LRU策略，那recencyQueue的具体作用是什么？
   //  - accessQueue在加锁的情况下记录read信息，而recencyQueue在不加锁的情况下使用
   //  - recencyQueue最终信息也也同步到accessQueue中(按顺序往队尾加)，这样的设计在高并发读的情况下 确实不错
   recencyQueue =
       map.usesAccessQueue()
           ? new ConcurrentLinkedQueue>()
           : LocalCache.>discardingQueue();
   // 和"写"淘汰策略相关，其实每次写包含了读(影响accessQueue)，反之不然.
   writeQueue =
       map.usesWriteQueue()
           ? new WriteQueue()
           : LocalCache.>discardingQueue();
   // 和"读"策略相关
   accessQueue =
       map.usesAccessQueue()
           ? new AccessQueue()
           : LocalCache.>discardingQueue();
 }

     
    以上便是LocalCache、Segment的创建过程，下面看看具体的操作实现
      
   
  
    GET操作
     
  
       
   
    •  
      V get(Object key, int hash)
       
      V get(Object key, int hash) {
  try {
    // count表示此segment中entry的数量, 大于0则尝试读取
    if (count != 0) { // read-volatile
      long now = map.ticker.read();
      // 根据key找到是否存活状态的entry，主要操作：
      //  - 如果key为null, 则可能被GC了，触发清理key/value引用队列
      //  - 如果此entry已过期，尝试清除过期的entries
      ReferenceEntry e = getLiveEntry(key, hash, now);
      if (e == null) {
        return null;
      }

      V value = e.getValueReference().get();
      if (value != null) {
        // 记录读信息
        recordRead(e, now);
        // 如果设置了刷新参数refreshNanos，并且到了刷新时间点了则进行刷新，等待返回结果
        return scheduleRefresh(e, e.getKey(), hash, value, now, map.defaultLoader);
      }
      // 清理一次引用队列
      tryDrainReferenceQueues();
    }
    return null;
  } finally {
    // 后置读清除，之前提到过 要达到一定读次数才会清除
    postReadCleanup();
  }
}

       
      •  
   
    •  
      V get(K key, int hash, CacheLoader loader) throws ExecutionException
       
        V get(K key, int hash, CacheLoader loader) throws ExecutionException {
    checkNotNull(key);
    checkNotNull(loader);
    try {
      if (count != 0) { // read-volatile
        // don't call getLiveEntry, which would ignore loading values
        ReferenceEntry e = getEntry(key, hash);
        if (e != null) {
          long now = map.ticker.read();
          V value = getLiveValue(e, now);
          if (value != null) {
            recordRead(e, now);
            statsCounter.recordHits(1);
            return scheduleRefresh(e, key, hash, value, now, loader);
          }
          ValueReference valueReference = e.getValueReference();
          if (valueReference.isLoading()) {
            // 多线程的情况下，此value可能正在加载，等待加载完成返回
            return waitForLoadingValue(e, key, valueReference);
          }
        }
      }

      // at this point e is either null or expired;
      // 如果上面操作没有成功返回，则锁定并用loader加载数据
      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();
    }
  }  

       
      •  
   
    •  
      scheduleRefresh 如果必要的话，刷新数据
       
       V scheduleRefresh(
     ReferenceEntry entry,
     K key,
     int hash,
     V oldValue,
     long now,
     CacheLoader loader) {
   // 设置了刷新时间
   // 到了刷新时间点
   // 此entry的value没有在加载中  
   if (map.refreshes()
       && (now - entry.getWriteTime() > map.refreshNanos)
       && !entry.getValueReference().isLoading()) { // todo
     V newValue = refresh(key, hash, loader, true);
     if (newValue != null) {
       return newValue;
     }
   }
   return oldValue;
 }

       
      •  
   
    •  
      refresh
       
       V refresh(K key, int hash, CacheLoader loader, boolean checkTime) {
   // 这步操作主要目的是 为当前key对应的entry(没有则创建) 的valueReference设置这样一个值LoadingValueReference,
   // 表示此值正在加载，多线程环境下，其他线程只需等待结果返回即可
   // 全程加锁场景下
   final LoadingValueReference loadingValueReference =
       insertLoadingValueReference(key, hash, checkTime);
   if (loadingValueReference == null) {
     return null;
   }

   // 异步加载数据，实际上这里的异步主要是返回值和保存值的异步操作
   ListenableFuture result = loadAsync(key, hash, loadingValueReference, loader);
   if (result.isDone()) {
     try {
       // 从Future中拿到值
       return Uninterruptibles.getUninterruptibly(result);
     } catch (Throwable t) {
       // don't let refresh exceptions propagate; error was already logged
     }
   }
   return null;
 }        

       
      •  
   
    •  
      loadAsync 来看看真正执行数据"异步"加载的方法
       
       ListenableFuture loadAsync(
     final K key,
     final int hash,
     final LoadingValueReference loadingValueReference,
     CacheLoader loader) {
   // 真正会去加载数据的方法
   // 会调用用户自定义的loader进行加载，并将值以Future包装返回  
   final ListenableFuture loadingFuture = loadingValueReference.loadFuture(key, loader);
   loadingFuture.addListener(
       new Runnable() {
         @Override
         public void run() {
           try {
             // 获取最新的值，更新entry中的value,记录stats等信息
             getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
           } catch (Throwable t) {
             logger.log(Level.WARNING, "Exception thrown during refresh", t);
             loadingValueReference.setException(t);
           }
         }
       },
           // 目前此方法directExecutor的作用是同步执行，当然也可以传一个支持异步的Executor
           // 也就是getAndRecordStats方法将会和 return loadingFuture异步执行,
           // 这样外层loadingFuture.get()取值和保存record信息就实现了异步执行，提高效率
       directExecutor());
   return loadingFuture;
 }

       
      如果先处理getAndRecordStats操作，在返回value值就变成来同步加载数据了，如下：
       
      •  
   
    •  
      loadSync 同步加载数据
       
       V loadSync(
     K key,
     int hash,
     LoadingValueReference loadingValueReference,
     CacheLoader loader)
     throws ExecutionException {
   ListenableFuture loadingFuture = loadingValueReference.loadFuture(key, loader);
   return getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
 }

       
      •  
   
    •  
      loadFuture 真正加载数据的方法，此方法比较巧妙，会先将值设置回LoadingValueReference#futureValue中，再进行返回；这样的好处是 多线程环境下，读线程可以拿到该新值然后直接返回
       
      public ListenableFuture loadFuture(K key, CacheLoader loader) {
  try {
    stopwatch.start();
    V previousValue = oldValue.get();
    if (previousValue == null) {
      V newValue = loader.load(key);
      // 尝试将值先设置到futureValue中(并发场景下，读线程可以立即取到值)，成功了立即返回futureValue，
      // 失败了也没关系，包装一个ImmediateFuture返回
      return set(newValue) ? futureValue : Futures.immediateFuture(newValue);
    }
    ListenableFuture newValue = loader.reload(key, previousValue);
    if (newValue == null) {
      return Futures.immediateFuture(null);
    }
    // To avoid a race, make sure the refreshed value is set into loadingValueReference
    // *before* returning newValue from the cache query.
    // 为避免竞争等待，将加载的值在返回存储到cache之前，提前设置回LoadingValueReference#futureValue中
    // 多线程读操作情况下 在Segment#waitForLoadingValue中可以直接拿到这个值返回
    return transform(
        newValue,
        new com.google.common.base.Function() {
          @Override
          public V apply(V newValue) {
            LoadingValueReference.this.set(newValue);
            return newValue;
          }
        },
            // com.google.common.util.concurrent.DirectExecutor枚举实例，实际上也是串行操作
        directExecutor());
  } catch (Throwable t) {
    ListenableFuture result = setException(t) ? futureValue : fullyFailedFuture(t);
    if (t instanceof InterruptedException) {
      Thread.currentThread().interrupt();
    }
    return result;
  }
}

       
      •  
   
    •  
      最后便是保存最新value和记录stats信息 getAndRecordStats， storeLoadedValue
       
       /** Waits uninterruptibly for {@code newValue} to be loaded, and then records loading stats. */
 V getAndRecordStats(
     K key,
     int hash,
     LoadingValueReference loadingValueReference,
     ListenableFuture newValue)
     throws ExecutionException {
   V value = null;
   try {
     // 自旋的方式从future中取值
     value = getUninterruptibly(newValue);
     if (value == null) {
       throw new InvalidCacheLoadException("CacheLoader returned null for key " + key + ".");
     }
     // 记录stats信息
     statsCounter.recordLoadSuccess(loadingValueReference.elapsedNanos());
     // 保存加载的新值
     storeLoadedValue(key, hash, loadingValueReference, value);
     return value;
   } finally {
     if (value == null) {
       statsCounter.recordLoadException(loadingValueReference.elapsedNanos());
       removeLoadingValue(key, hash, loadingValueReference);
     }
   }
 }

 // 将加载好的值设置到entry value中，也就是将LoadingValueReference类型的值设置为真实的ValueReference类型的值
 boolean storeLoadedValue(
     K key, int hash, LoadingValueReference oldValueReference, V newValue) {
   lock();
   try {
     long now = map.ticker.read();
     // 引用清理，过期清理
     preWriteCleanup(now);

     int newCount = this.count + 1;
     if (newCount > this.threshold) { // ensure capacity
       expand();
       newCount = this.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()) {
       K entryKey = e.getKey();
       if (e.getHash() == hash
           && entryKey != null
           && map.keyEquivalence.equivalent(key, entryKey)) {
         ValueReference valueReference = e.getValueReference();
         V entryValue = valueReference.get();
         // replace the old LoadingValueReference if it's live, otherwise
         // perform a putIfAbsent
         if (oldValueReference == valueReference
             || (entryValue == null && valueReference != UNSET)) {
           ++modCount;
           if (oldValueReference.isActive()) {
             RemovalCause cause =
                 (entryValue == null) ? RemovalCause.COLLECTED : RemovalCause.REPLACED;
             enqueueNotification(key, hash, entryValue, oldValueReference.getWeight(), cause);
             newCount--;
           }
           setValue(e, key, newValue, now);
           this.count = newCount; // write-volatile
           evictEntries(e);
           return true;
         }

         // the loaded value was already clobbered
         enqueueNotification(key, hash, newValue, 0, RemovalCause.REPLACED);
         return false;
       }
     }

     ++modCount;
     ReferenceEntry newEntry = newEntry(key, hash, first);
     // 保存新值
     setValue(newEntry, key, newValue, now);
     table.set(index, newEntry);
     this.count = newCount; // write-volatile
     // 如果达到了限制则清理entry
     evictEntries(newEntry);
     return true;
   } finally {
     unlock();
     postWriteCleanup();
   }
 }
 
  /** Sets a new value of an entry. Adds newly created entries at the end of the access queue. */
  @GuardedBy("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);
    // 这一步就是用真实的ValueReference替换临时的LoadingValueReference
    entry.setValueReference(valueReference);
    recordWrite(entry, weight, now);
    previous.notifyNewValue(value);
  }

       
      •  
  
     
  
    来看看get操作涉及到的方法，这些方法比较公用，很多操作都会用到
     
  
       
   
    •  
      getLiveEntry 根据key拿到 "存活"的entry
       
       ReferenceEntry getLiveEntry(Object key, int hash, long now) {
   ReferenceEntry e = getEntry(key, hash);
   if (e == null) {
     return null;
   } else if (map.isExpired(e, now)) { // entry是否过期
     // 尝试清除过期的entry
     tryExpireEntries(now);
     return null;
   }
   return e;
 }    

       
      •  
   
    •  
      getEntry 执行获取entry操作
       
       ReferenceEntry getEntry(Object key, int hash) {
   for (ReferenceEntry e = getFirst(hash); e != null; e = e.getNext()) {
     if (e.getHash() != hash) {
       continue;
     }

     K entryKey = e.getKey();
     if (entryKey == null) {
       // 可能被GC了，尝试清除引用队列
       tryDrainReferenceQueues();
       continue;
     }
     // key是否相等
     if (map.keyEquivalence.equivalent(key, entryKey)) {
       return e;
     }
   }

   return null;
 }      

       
      •  
   
    •  
      tryDrainReferenceQueues 尝试清除引用队列
       
      void tryDrainReferenceQueues() {
  // 加锁清除
  if (tryLock()) {
    try {
      drainReferenceQueues();
    } finally {
      unlock();
    }
  }
}

// 最终又到这里了...
void drainReferenceQueues() {
  if (map.usesKeyReferences()) {
    drainKeyReferenceQueue();
  }
  if (map.usesValueReferences()) {
    drainValueReferenceQueue();
  }
}

       
      •  
   
    •  
      isExpired 是否已过期了
       
       /** Returns true if the entry has expired. */
 boolean isExpired(ReferenceEntry entry, long now) {
   checkNotNull(entry);
   // 如果设置了此参数&过期了
   if (expiresAfterAccess() && (now - entry.getAccessTime() >= expireAfterAccessNanos)) {
     return true;
   }
   if (expiresAfterWrite() && (now - entry.getWriteTime() >= expireAfterWriteNanos)) {
     return true;
   }
   return false;
 } 

       
      •  
   
    •  
      tryExpireEntries
       
       void tryExpireEntries(long now) {
 // 加锁清理
   if (tryLock()) {
     try {
       expireEntries(now);
     } finally {
       unlock();
       // don't call postWriteCleanup as we're in a read
     }
   }
 }      

       
      •  
   
    •  
      expireEntries
       
       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();
     }
   }
 }

       
      •  
  
     
  
    PUT操作
     
  
       
   
    •  
      LocalCache#put(K key, V value);
       
         public V put(K key, V value) {
     checkNotNull(key);
     checkNotNull(value);
     int hash = hash(key);
     return segmentFor(hash).put(key, hash, value, false);
   }

       
      •  
  
     
  
    真正的实现在Segment中 LocalCache.Segment#put(K key, int hash, V value, boolean onlyIfAbsent)
     
  
       V put(K key, int hash, V value, boolean onlyIfAbsent) {
     lock();
     try {
       long now = map.ticker.read();
       // 添加前先清理被GC的entry和已过期的entry
       preWriteCleanup(now);

       int newCount = this.count + 1;
       if (newCount > this.threshold) { // ensure capacity
         // 在put操作之前进行扩容
         // storeLoadedValue也是在存值之前进行扩容
         expand();
         newCount = this.count + 1;
       }

       AtomicReferenceArray> table = this.table;
       int index = hash & (table.length() - 1);
       ReferenceEntry first = table.get(index);

       // 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();

           if (entryValue == null) {
             ++modCount;
             // 说明value已经被GC了
             if (valueReference.isActive()) {
               // 放进删除队列 待删除监听器处理
               enqueueNotification(
                   key, hash, entryValue, valueReference.getWeight(), 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(e);
             return null;
           } else if (onlyIfAbsent) { // onlyIfAbsent表示仅在不存在的情况下put, 存在的情况下直接返回
             // Mimic
             // "if (!map.containsKey(key)) ...
             // else return map.get(key);
             recordLockedRead(e, now);
             return entryValue;
           } else { // 否则的话便是新值取代旧值
             // clobber existing entry, count remains unchanged
             ++modCount;
             enqueueNotification(
                 key, hash, entryValue, valueReference.getWeight(), RemovalCause.REPLACED);
             setValue(e, key, value, now);
             evictEntries(e);
             return entryValue;
           }
         }
       }

       // 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

       // put之后根据maxWeight进行清理超出的部分
       evictEntries(newEntry);
       return null;
     } finally {
       unlock();
       // 这一步便是在无锁的情况下通过 删除监听器处理被删除的entry
       postWriteCleanup();
     }
   } 

     
  
    可以看到put操作之前有一步是否扩容判断
     
  
       
   
    •  
      expand 执行扩容
       
       void expand() {
   AtomicReferenceArray> oldTable = table;
   int oldCapacity = oldTable.length();
   if (oldCapacity >= MAXIMUM_CAPACITY) {
     return;
   }

   int newCount = count;
   AtomicReferenceArray> newTable = newEntryArray(oldCapacity << 1);
   // 0.75的扩容因子
   threshold = newTable.length() * 3 / 4;
   int newMask = newTable.length() - 1;
   for (int oldIndex = 0; oldIndex < oldCapacity; ++oldIndex) {
     // We need to guarantee that any existing reads of old Map can
     // proceed. So we cannot yet null out each bin.
     ReferenceEntry head = oldTable.get(oldIndex);

     if (head != null) {
       ReferenceEntry next = head.getNext();
       int headIndex = head.getHash() & newMask;

       // Single node on list
       if (next == null) {
         newTable.set(headIndex, head);
       } else {
         // Reuse the consecutive sequence of nodes with the same target
         // index from the end of the list. tail points to the first
         // entry in the reusable list.
         // 这步操作主要是找到最后newIndex相同的list, 然后一次性放在新table index上
         ReferenceEntry tail = head;
         int tailIndex = headIndex;
         for (ReferenceEntry e = next; e != null; e = e.getNext()) {
           int newIndex = e.getHash() & newMask;
           if (newIndex != tailIndex) {
             // The index changed. We'll need to copy the previous entry.
             tailIndex = newIndex;
             tail = e;
           }
         }
         // 因为采用的是2倍扩容机制，所以要么stay at same index， 要么是oldIndex + oldCapacity上
         // 因此这里直接设置table[tailIndex], 无须考虑此位置是否有值
         newTable.set(tailIndex, tail);

         // Clone nodes leading up to the tail.
         // 挨个遍历到新table上
         for (ReferenceEntry e = head; e != tail; e = e.getNext()) {
           int newIndex = e.getHash() & newMask;
           ReferenceEntry newNext = newTable.get(newIndex);
           ReferenceEntry newFirst = copyEntry(e, newNext);
           if (newFirst != null) {
             newTable.set(newIndex, newFirst);
           } else {
             // 遇到key/value被GC掉的entry直接清除
             removeCollectedEntry(e);
             newCount--;
           }
         }
       }
     }
   }
   table = newTable;
   this.count = newCount;
 }      

       
      •  
  
     
  
    以上便是GET和PUT操作的流程，其他操作如compute, reclaimKey等都大同小异，不在赘述
     
  
    以上是个人理解，如有问题请指出，谢谢！
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(JAVA)
    
        
    
            
    
                
      
                    
    • Long类型前后端数据不一致
                        igotyback
前端
                        
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      
                    
      • 
                    
    • LocalDateTime 转 String
                        igotyback
java开发语言
                        
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      
                    
      • 
                    
    • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      
                    
      • 
                    
    • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      
                    
      • 
                    
    • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      
                    
      • 
                    
    • 简单了解 JVM
                        记得开心一点啊
jvm
                        
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      
                    
      • 
                    
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      
                    
      • 
                    
    • Java企业面试题3
                        马龙强_
java
                        
      1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
      
                    
      • 
                    
    • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      
                    
      • 
                    
    • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
      一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
      
                    
      • 
                    
    • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
      欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
      
                    
      • 
                    
    • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
      在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
      
                    
      • 
                    
    • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      
                    
      • 
                    
    • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      
                    
      • 
                    
    • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
      一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
      
                    
      • 
                    
    • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
      发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
      
                    
      • 
                    
    • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
      在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
      
                    
      • 
                    
    • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
      文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
      
                    
      • 
                    
    • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
      文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
      
                    
      • 
                    
    • 博客网站制作教程
                        2401_85194651
javamaven
                        
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
      
                    
      • 
                    
    • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
      目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
      
                    
      • 
                    
    • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
      博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
      
                    
      • 
                    
    • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
      在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
      
                    
      • 
                    
    • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
      切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
      
                    
      • 
                    
    • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
      文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
      
                    
      • 
                    
    • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
      文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
      
                    
      • 
                                
    • 插入表主键冲突做更新
                                    a-john

                                    
      有以下场景： 
用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 
问题： 
如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 
解决： 
mysql中提供了一个sql语
      
                                
      • 
                                
    • Android xml资源文件中@、@android:type、@*、？、@+含义和区别
                                    Cb123456
@+@?@*
                                    
      一.@代表引用资源 
1.引用自定义资源。格式：@[package:]type/name 
android：text="@string/hello" 
  
2.引用系统资源。格式：@android:type/name 
    android:textColor="@android:color/opaque_red"
      
                                
      • 
                                
    • 数据结构的基本介绍
                                    天子之骄
数据结构散列表树、图线性结构价格标签
                                    
      数据结构的基本介绍 
数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。 
  
经典的数据结构大致如下： 
  
一：线性数据结构 
(1)：列表 
a
      
                                
      • 
                                
    • 通过二维码开放平台的API快速生成二维码
                                    一炮送你回车库
api
                                    
       现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。 
       html代码如下:(二维码将生成在这div下)    
?       1      
 &nbs
      
                                
      • 
                                
    • ImageIO读取一张图片改变大小
                                    3213213333332132
javaIOimageBufferedImage
                                    
      
package com.demo;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/**
 * @Description 读取一张图片改变大小
 * @author FuJianyon
      
                                
      • 
                                
    • myeclipse集成svn（一针见血）
                                    7454103
eclipseSVNMyEclipse
                                    
                                       &n
      
                                
      • 
                                
    • 装箱与拆箱----autoboxing和unboxing
                                    darkranger
J2SE
                                    
      4.2　自动装箱和拆箱 
 
基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 
 
4.2.1　autoboxing和unboxing 
 
在Java中，所有要处理的东西几乎都是对象(Object)
      
                                
      • 
                                
    • ajax传统的方式制作ajax
                                    aijuans
Ajax
                                    
      //这是前台的代码 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
      
                                
      • 
                                
    • 只用jre的eclipse是怎么编译java源文件的？
                                    avords
javaeclipsejdktomcat
                                    
      eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ 
&nb
      
                                
      • 
                                
    • 前端模块化
                                    bee1314
模块化
                                    
      背景：   前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。       JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
      
                                
      • 
                                
    • 处理百万级以上的数据处理
                                    bijian1013
oraclesql数据库大数据查询
                                    
      一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。 
        2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
      
                                
      • 
                                
    • mac 卸载 java 1.7 或更高版本
                                    征客丶
javaOS
                                    
      卸载 java 1.7 或更高 
sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 
成功执行此命令后，还可以执行 java 与 javac 命令 
 
sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 
成功执行此命令后，还可以执行 java 
      
                                
      • 
                                
    • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析
                                    bit1129
Stream
                                    
      第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 
第二部，Spark Streaming读取Kafka中的数据，进行实时分析 
  
本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 
1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
      
                                
      • 
                                
    • Erlang vs TNSDL
                                    bookjovi
erlang
                                    
        
    TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
      
                                
      • 
                                
    • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个
                                    ljy325
企业应用
                                    
      　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 
 
相关新闻： 
（1）IT行业成五大疾病重灾区：过劳死平均37.9岁 

      
                                
      • 
                                
    • 读《研磨设计模式》-代码笔记-原型模式
                                    bylijinnan
java设计模式
                                    
      声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * Effective Java 建议使用copy constructor or copy factory来代替clone()方法：
 * 1.public Product copy(Product p){}
 * 2.publi
      
                                
      • 
                                
    • 配置管理---svn工具之权限配置
                                    chenyu19891124
SVN
                                    
      今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 
安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 
pepos 
   component 
   webapps 
在conf里面的auth里赋予的权限配置为 
[groups]
      
                                
      • 
                                
    • 浅谈程序员的数学修养
                                    comsci
设计模式编程算法面试招聘
                                    
               
                        浅谈程序员的数学修养 
      
                                
      • 
                                
    • 批量执行 bulk collect与forall用法
                                    daizj
oraclesqlbulk collectforall
                                    
      BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 
FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。 
    有关FORALL语句的用法请参考：批量SQL之 F
      
                                
      • 
                                
    • Linux下使用rsync最快速删除海量文件的方法
                                    dongwei_6688
OS
                                    
      1、先安装rsync：yum install rsync 
2、建立一个空的文件夹：mkdir /tmp/test 
3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。 

      
                                
      • 
                                
    • Yii CModel中rules验证规格
                                    dcj3sjt126com
rulesyiivalidate
                                    
      Yii cValidator主要用法分析：  
 yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError 
 
      
                                
      • 
                                
    • 基于vagrant的redis主从实验
                                    dcj3sjt126com
vagrant
                                    
      平台: Mac 
工具: Vagrant 
系统: Centos6.5 
实验目的: Redis主从 
  
实现思路 
制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box 
  
制作sentos6.5+redis的box 
  
mkdir vagrant_redis 
cd vagrant_
      
                                
      • 
                                
    • Memcached(二)、Centos安装Memcached服务器
                                    frank1234
centosmemcached
                                    
      一、安装gcc 
rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 
 
开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]：

建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码......


rpm -ivh kernel-head
      
                                
      • 
                                
    • Remove Duplicates from Sorted List
                                    hcx2013
remove
                                    
      Given a sorted linked list, delete all duplicates such that each element appear only once. 
For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
      
                                
      • 
                                
    • Spring4新特性——JSR310日期时间API的支持
                                    jinnianshilongnian
spring4
                                    
      Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
      
                                
      • 
                                
    • 浅谈enum与单例设计模式
                                    247687009
java单例
                                    
      在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构
造器，导出静态成员变量，以便调用者访问。

第一种 
package singleton;

public class Singleton {
        //导出全局成员
        public final static Singleton INSTANCE = new S
      
                                
      • 
                                
    • 使用switch条件语句需要注意的几点
                                    openwrt
cbreakswitch
                                    
      1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 
 
int main()
{
    int n = 1;
    switch(n) {
    case 1:
        printf("--1--\n");
    default:
        printf("defa
      
                                
      • 
                                
    • 配置Spring Mybatis JUnit测试环境的应用上下文
                                    schnell18
springmybatisJUnit
                                    
      Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 
 
 单元测试的app context不支持从外部properties文件注入属性 
 @Value注解不能解析带通配符的路径字符串 
 
解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 
第二个问题的具体实例是： 
   
      
                                
      • 
                                
    • Java 定时任务总结一
                                    tuoni
javaspringtimerquartztimertask
                                    
       Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
      
                                
      • 
                                
    • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法
                                    yangshangchuan
rank相似度计算文本相似度词袋模型余弦相似度
                                    
      本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。 
  
最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下： 
    1、注册多个账号（一般10个以上）。 
    2、从多个账号中选择一个账号，发表1-2篇博文
      
                                
      •