Lines Matching refs:table
51 * <p>The resulting hash table supports full concurrency of retrievals and
54 * and there is <i>not</i> any support for locking the entire table
64 * reflecting the state of the hash table at some point at or since the
150 * other kind of hash table is a relatively slow operation, so, when
151 * possible, it is a good idea to provide estimates of expected table
170 * hint for internal sizing. The table is internally partitioned to try to
174 * as many threads as will ever concurrently modify the table. Using a
291 * reclaimed entries will not be copied over during table expansions, for
325 * entries or expanding the internal table.
540 * The basic strategy is to subdivide the table among Segments,
541 * each of which itself is a concurrently readable hash table.
587 * The segments, each of which is a specialized hash table
703 * Segments maintain a table of entry lists that are ALWAYS
722 * "count" field, and should not look at table entries if
731 * can reveal that the table has grown but the threshold
745 * Number of updates that alter the size of the table. This is used
754 * The table is expanded when its size exceeds this threshold. (The
760 * The per-segment table.
762 volatile AtomicReferenceArray<E> table;
773 * Sets table to new HashEntry array. Call only while holding lock or in
778 this.table = newTable;
785 AtomicReferenceArray<E> table = this.table;
786 return table.get(hash & (table.length() - 1));
848 AtomicReferenceArray<E> table = this.table;
849 int length = table.length();
851 for (E e = table.get(i); e != null; e = s.getNext(e)) {
933 AtomicReferenceArray<E> table = this.table;
934 int index = hash & (table.length() - 1);
936 E first = table.get(index);
961 table.set(index, newEntry);
970 * Expands the table if possible.
973 AtomicReferenceArray<E> oldTable = table;
987 * a table doubles. The nodes they replace will be garbage
989 * reader thread that may be in the midst of traversing table
1039 table = newTable;
1047 AtomicReferenceArray<E> table = this.table;
1048 int index = hash & (table.length() - 1);
1049 E first = table.get(index);
1069 table.set(index, newFirst);
1086 AtomicReferenceArray<E> table = this.table;
1087 int index = hash & (table.length() - 1);
1088 E first = table.get(index);
1110 table.set(index, newFirst);
1130 AtomicReferenceArray<E> table = this.table;
1131 int index = hash & (table.length() - 1);
1132 E first = table.get(index);
1152 table.set(index, newFirst);
1172 AtomicReferenceArray<E> table = this.table;
1173 int index = hash & (table.length() - 1);
1174 E first = table.get(index);
1191 table.set(index, newFirst);
1207 AtomicReferenceArray<E> table = this.table;
1208 for (int i = 0; i < table.length(); i++) {
1209 table.set(i, null);
1233 * table was never actually empty at any point. Note the
1274 // continuous async changes in table, resort to locking.
1335 * Tests if the specified object is a key in this table.
1339 * this table, as determined by the {@code equals} method;
1354 * table, and so is much slower than method {@code containsKey}.
1418 * Maps the specified key to the specified value in this table. Neither the
1649 currentTable = seg.table;
1676 * Finds the next entry in the current table. Returns true if an entry
2029 AtomicReferenceArray<E> table = segment.table;
2030 int index = hash & (table.length() - 1);
2031 E first = table.get(index);
2034 table.set(index, entry);
