为何Java ConcurrentHashMap的Segment数组大小必须为2的幂？

Great question! This design choice boils down to optimizing performance, hash distribution, and low-level memory efficiency—let’s break it down in plain terms:

• Blazing-fast index calculation
  When the array size is a power of two, we can replace the slow modulo operation (hash % size) with a simple bitwise AND: hash & (size - 1). Since size - 1 for a power-of-two value is a binary number with all bits set to 1 (e.g., 16-1=15 → 1111), this bitwise trick directly grabs the lower x bits of the hash (where size=2^x). It’s way faster than modulo, which is critical for a high-concurrency container where every nanosecond adds up.

• More even hash distribution
  If we used a non-power-of-two size (like the exact concurrency level, say 10), the modulo operation could lead to lopsided entry counts across Segments. Many hash functions produce values with patterned lower bits, and non-power-of-two sizes don’t leverage all those bits for index calculation. A power-of-two size ensures every bit in the hash contributes to the index, minimizing collisions and keeping load balanced across Segments—so no single Segment becomes a bottleneck.

• Better memory alignment & cache efficiency
  You were spot-on about memory allocation! JVMs optimize memory access for structures that align with hardware cache lines and memory page boundaries. Power-of-two array sizes are far more likely to be aligned properly, which means when the CPU loads parts of the Segment array into cache, it can do so more efficiently. This reduces cache misses and speeds up Segment access—a huge win for concurrent performance.

• Simpler expansion logic
  While Java 8 reworked ConcurrentHashMap’s internals (moving away from Segment-based locking for most operations), early versions relied on Segment expansion. A power-of-two size makes splitting Segments during expansion trivial: when you double the array size, you just use one extra bit from the hash to decide which new Segment an entry belongs to. No messy rehashing logic needed—clean, efficient, and safe to implement under concurrency.

To confirm this design constraint, here’s the relevant snippet from Java 8’s ConcurrentHashMap class comment, which explicitly enforces that the maximum number of Segments is a power of two:

/** 
 * The maximum number of segments to allow; used to bound 
 * constructor arguments. Must be power of two less than 1 << 24. 
 */ 
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative

This shows the power-of-two rule is a core design principle for Segments, even as the implementation evolved.

内容的提问来源于stack exchange，提问作者Rex