code: @Override
      public int size() {
          // Try a few times to get accurate count. On failure due to
          // continuous async changes in table, resort to locking.
          final Segment<K,V>[] segments = this.segments;
          int size;
          boolean overflow; // true if size overflows 32 bits
          long sum;         // sum of modCounts
          long last = 0L;   // previous sum
          int retries = -1; // first iteration isn't retry
          try {
              for (;;) {
                  if (retries++ == RETRIES_BEFORE_LOCK) {
                      for (int j = 0; j < segments.length; ++j)
                       {
                        ensureSegment(j).lock(); // force creation
                      }
                  }
                  sum = 0L;
                  size = 0;
                  overflow = false;
                  for (int j = 0; j < segments.length; ++j) {
                      Segment<K,V> seg = segmentAt(segments, j);
                      if (seg != null) {
                          sum += seg.modCount;
                          int c = seg.count;
                          if (c < 0 || (size += c) < 0) {
                            overflow = true;
                          }
                      }
                  }
                  if (sum == last) {
                    break;
                  }
                  last = sum;
              }
          } finally {
              if (retries > RETRIES_BEFORE_LOCK) {
                  for (int j = 0; j < segments.length; ++j) {
                    segmentAt(segments, j).unlock();
                  }
              }
          }
          return overflow ? Integer.MAX_VALUE : size;
      }
docs: Returns the number of key-value mappings in this map.  If the
  map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
  <tt>Integer.MAX_VALUE</tt>.
  
  @return the number of key-value mappings in this map