详解Java的 StringTable

1
oop StringTable::do_intern(Handle string_or_null_h, const jchar* name,
2
                           int len, uintx hash, TRAPS) {
3
  HandleMark hm(THREAD);  // cleanup strings created
4
  Handle string_h;
5

6
  if (!string_or_null_h.is_null()) {
7
    string_h = string_or_null_h;
8
  } else {
9
    string_h = java_lang_String::create_from_unicode(name, len, CHECK_NULL);
10
  }
11

12
  assert(java_lang_String::equals(string_h(), name, len),
13
         "string must be properly initialized");
14
  assert(len == java_lang_String::length(string_h()), "Must be same length");
15

16
  // Notify deduplication support that the string is being interned.  A string
17
  // must never be deduplicated after it has been interned.  Doing so interferes
18
  // with compiler optimizations done on e.g. interned string literals.
19
  if (StringDedup::is_enabled()) {
20
    StringDedup::notify_intern(string_h());
21
  }
22

23
  StringTableLookupOop lookup(THREAD, hash, string_h);
24
  StringTableGet stg(THREAD);
25

26
  bool rehash_warning;
27
  do {
28
    // Callers have already looked up the String using the jchar* name, so just go to add.
29
    WeakHandle wh(_oop_storage, string_h);
30
    // The hash table takes ownership of the WeakHandle, even if it's not inserted.
31
    if (_local_table->insert(THREAD, lookup, wh, &rehash_warning)) {
32
      update_needs_rehash(rehash_warning);
33
      return wh.resolve();
34
    }
35
    // In case another thread did a concurrent add, return value already in the table.
36
    // This could fail if the String got gc'ed concurrently, so loop back until success.
37
    if (_local_table->get(THREAD, lookup, stg, &rehash_warning)) {
38
      update_needs_rehash(rehash_warning);
39
      return stg.get_res_oop();
40
    }
41
  } while(true);
42
}

1
// Rehash
2
bool StringTable::do_rehash() {
3
  if (!_local_table->is_safepoint_safe()) {
4
    return false;
5
  }
6

7
  // We use current size, not max size.
8
  size_t new_size = _local_table->get_size_log2(Thread::current());
9
  StringTableHash* new_table = new StringTableHash(new_size, END_SIZE, REHASH_LEN, true);
10
  // Use alt hash from now on
11
  _alt_hash = true;
12
  if (!_local_table->try_move_nodes_to(Thread::current(), new_table)) {
13
    _alt_hash = false;
14
    delete new_table;
15
    return false;
16
  }
17

18
  // free old table
19
  delete _local_table;
20
  _local_table = new_table;
21

22
  return true;
23
}
24

25
void StringTable::rehash_table() {
26
  static bool rehashed = false;
27
  log_debug(stringtable)("Table imbalanced, rehashing called.");
28

29
  // Grow instead of rehash.
30
  if (get_load_factor() > PREF_AVG_LIST_LEN &&
31
      !_local_table->is_max_size_reached()) {
32
    log_debug(stringtable)("Choosing growing over rehashing.");
33
    trigger_concurrent_work();
34
    _needs_rehashing = false;
35
    return;
36
  }
37
  // Already rehashed.
38
  if (rehashed) {
39
    log_warning(stringtable)("Rehashing already done, still long lists.");
40
    trigger_concurrent_work();
41
    _needs_rehashing = false;
42
    return;
43
  }
44

45
  _alt_hash_seed = AltHashing::compute_seed();
46
  {
47
    if (do_rehash()) {
48
      rehashed = true;
49
    } else {
50
      log_info(stringtable)("Resizes in progress rehashing skipped.");
51
    }
52
  }
53
  _needs_rehashing = false;
54
}