Java 类com.google.common.cache.CacheBuilder.NullListener 实例源码

项目：guava-mock 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue =
      (removalListener == NullListener.INSTANCE)
          ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
          : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：googles-monorepo-demo 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue =
      (removalListener == NullListener.INSTANCE)
          ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
          : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：codebuff 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */

LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();
  keyEquivalence = builder.getKeyEquivalence();
  valueEquivalence = builder.getValueEquivalence();
  maxWeight = builder.getMaximumWeight();
  weigher = builder.getWeigher();
  expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
  expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
  refreshNanos = builder.getRefreshNanos();
  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
    ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
    : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
  ticker = builder.getTicker(recordsTime());
  entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
  globalStatsCounter = builder.getStatsCounterSupplier().get();
  defaultLoader = loader;
  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.

  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;
  this.segments = newSegmentArray(segmentCount);
  int segmentCapacity = initialCapacity / segmentCount;
  if (segmentCapacity * segmentCount < initialCapacity) {
    ++segmentCapacity;
  }

  int segmentSize = 1;
  while (segmentSize < segmentCapacity) {
    segmentSize <<= 1;
  }
  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());
    }
  }
}

项目：codebuff 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */

LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();
  keyEquivalence = builder.getKeyEquivalence();
  valueEquivalence = builder.getValueEquivalence();
  maxWeight = builder.getMaximumWeight();
  weigher = builder.getWeigher();
  expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
  expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
  refreshNanos = builder.getRefreshNanos();
  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
    ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
    : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
  ticker = builder.getTicker(recordsTime());
  entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
  globalStatsCounter = builder.getStatsCounterSupplier().get();
  defaultLoader = loader;
  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.

  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;
  this.segments = newSegmentArray(segmentCount);
  int segmentCapacity = initialCapacity / segmentCount;
  if (segmentCapacity * segmentCount < initialCapacity) {
    ++segmentCapacity;
  }

  int segmentSize = 1;
  while (segmentSize < segmentCapacity) {
    segmentSize <<= 1;
  }
  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());
    }
  }
}

项目：codebuff 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */

LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();
  keyEquivalence = builder.getKeyEquivalence();
  valueEquivalence = builder.getValueEquivalence();
  maxWeight = builder.getMaximumWeight();
  weigher = builder.getWeigher();
  expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
  expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
  refreshNanos = builder.getRefreshNanos();
  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
    ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
    : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
  ticker = builder.getTicker(recordsTime());
  entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
  globalStatsCounter = builder.getStatsCounterSupplier().get();
  defaultLoader = loader;
  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.

  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;
  this.segments = newSegmentArray(segmentCount);
  int segmentCapacity = initialCapacity / segmentCount;
  if (segmentCapacity * segmentCount < initialCapacity) {
    ++segmentCapacity;
  }

  int segmentSize = 1;
  while (segmentSize < segmentCapacity) {
    segmentSize <<= 1;
  }
  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());
    }
  }
}

项目：codebuff 文件：LocalCache.java

/**
* Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
*/

     LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
 concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
 keyStrength = builder.getKeyStrength();
 valueStrength = builder.getValueStrength();
 keyEquivalence = builder.getKeyEquivalence();
 valueEquivalence = builder.getValueEquivalence();
 maxWeight = builder.getMaximumWeight();
 weigher = builder.getWeigher();
 expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
 expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
 refreshNanos = builder.getRefreshNanos();
 removalListener = builder.getRemovalListener();
 removalNotificationQueue = (removalListener == NullListener.INSTANCE)
                                ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
                                : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
 ticker = builder.getTicker(recordsTime());
 entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
 globalStatsCounter = builder.getStatsCounterSupplier().get();
 defaultLoader = loader;
 int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
 if (evictsBySize() && !customWeigher()) {
         initialCapacity = Math.min(initialCapacity, (int) maxWeight);
 }

 // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
 // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
 // entries. The special casing for size-based eviction is only necessary because that eviction
 // happens per segment instead of globally, so too many segments compared to the maximum size
 // will result in random eviction behavior.
 int segmentShift = 0;
 int segmentCount = 1;
 while (segmentCount < concurrencyLevel
        && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
         ++segmentShift;
         segmentCount <<= 1;
 }
 this.segmentShift = 32 - segmentShift;
 segmentMask = segmentCount - 1;
 this.segments = newSegmentArray(segmentCount);
 int segmentCapacity = initialCapacity / segmentCount;
 if (segmentCapacity * segmentCount < initialCapacity) {
         ++segmentCapacity;
 }
 int segmentSize = 1;
 while (segmentSize < segmentCapacity) {
         segmentSize <<= 1;
 }
 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());
   }
 }
     }

项目：codebuff 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */

LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();
  keyEquivalence = builder.getKeyEquivalence();
  valueEquivalence = builder.getValueEquivalence();
  maxWeight = builder.getMaximumWeight();
  weigher = builder.getWeigher();
  expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
  expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
  refreshNanos = builder.getRefreshNanos();
  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
    ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
    : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
  ticker = builder.getTicker(recordsTime());
  entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
  globalStatsCounter = builder.getStatsCounterSupplier().get();
  defaultLoader = loader;
  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.

  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;
  this.segments = newSegmentArray(segmentCount);
  int segmentCapacity = initialCapacity / segmentCount;
  if (segmentCapacity * segmentCount < initialCapacity) {
    ++segmentCapacity;
  }

  int segmentSize = 1;
  while (segmentSize < segmentCapacity) {
    segmentSize <<= 1;
  }
  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());
    }
  }
}

项目：codebuff 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue =
      (removalListener == NullListener.INSTANCE)
          ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
          : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：bts 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
      ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
      : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：j2objc 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
      ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
      : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：guava-libraries 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
      ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
      : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：VectorAttackScanner 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
      ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
      : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：guava 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @NullableDecl CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue =
      (removalListener == NullListener.INSTANCE)
          ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
          : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：guava 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @NullableDecl CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue =
      (removalListener == NullListener.INSTANCE)
          ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
          : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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

项目：cnGuava 文件：LocalCache.java

/**
 * 从builder中获取相应的配置参数。 Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
    concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

    keyStrength = builder.getKeyStrength();
    valueStrength = builder.getValueStrength();

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

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

    removalListener = builder.getRemovalListener();
    removalNotificationQueue = (removalListener == NullListener.INSTANCE) ? LocalCache
            .<RemovalNotification<K, V>> discardingQueue() : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

    int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
    if (evictsBySize() && !customWeigher()) {
        initialCapacity = Math.min(initialCapacity, (int) maxWeight);
    }

    // 找到最小2的次数的段数量，
    // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
    // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
    // entries. The special casing for size-based eviction is only necessary because that eviction
    // happens per segment instead of globally, so too many segments compared to the maximum size
    // will result in random eviction behavior.
    int segmentShift = 0;
    int segmentCount = 1;
    while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
        ++segmentShift;
        segmentCount <<= 1;
    }
    this.segmentShift = 32 - segmentShift;
    segmentMask = segmentCount - 1;

    this.segments = newSegmentArray(segmentCount);

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

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

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

项目：org.openntf.domino 文件：LocalCache.java

/**
 * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
 */
LocalCache(
    CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
  concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

  keyStrength = builder.getKeyStrength();
  valueStrength = builder.getValueStrength();

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

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

  removalListener = builder.getRemovalListener();
  removalNotificationQueue = (removalListener == NullListener.INSTANCE)
      ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
      : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

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

  int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
  if (evictsBySize() && !customWeigher()) {
    initialCapacity = Math.min(initialCapacity, (int) maxWeight);
  }

  // Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
  // maximumSize/Weight is specified in which case ensure that each segment gets at least 10
  // entries. The special casing for size-based eviction is only necessary because that eviction
  // happens per segment instead of globally, so too many segments compared to the maximum size
  // will result in random eviction behavior.
  int segmentShift = 0;
  int segmentCount = 1;
  while (segmentCount < concurrencyLevel
         && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
    ++segmentShift;
    segmentCount <<= 1;
  }
  this.segmentShift = 32 - segmentShift;
  segmentMask = segmentCount - 1;

  this.segments = newSegmentArray(segmentCount);

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

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

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