46
46
* concurrency for updates, and a maximum capacity to bound the map by. This
47
47
* implementation differs from {@link ConcurrentHashMap} in that it maintains a
48
48
* page replacement algorithm that is used to evict an entry when the map has
49
- * exceeded its capacity. Unlike the <tt> Java Collections Framework</tt> , this
49
+ * exceeded its capacity. Unlike the {@code Java Collections Framework} , this
50
50
* map does not have a publicly visible constructor and instances are created
51
51
* through a {@link Builder}.
52
52
* <p>
53
53
* An entry is evicted from the map when the entry size exceeds
54
- * its <tt> maximum capacity</tt> threshold.
54
+ * its {@code maximum capacity} threshold.
55
55
* <p>
56
56
* An {@code EvictionListener} may be supplied for notification when an entry
57
57
* is evicted from the map. This listener is invoked on a caller's thread and
62
62
* operation asynchronously, such as by submitting a task to an
63
63
* {@link java.util.concurrent.ExecutorService}.
64
64
* <p>
65
- * The <tt> concurrency level</tt> determines the number of threads that can
65
+ * The {@code concurrency level} determines the number of threads that can
66
66
* concurrently modify the table. Using a significantly higher or lower value
67
67
* than needed can waste space or lead to thread contention, but an estimate
68
68
* within an order of magnitude of the ideal value does not usually have a
74
74
* interfaces.
75
75
* <p>
76
76
* Like {@link java.util.Hashtable} but unlike {@link HashMap}, this class
77
- * does <em>not</em> allow <tt> null</tt> to be used as a key or value. Unlike
77
+ * does <em>not</em> allow {@code null} to be used as a key or value. Unlike
78
78
* {@link java.util.LinkedHashMap}, this class does <em>not</em> provide
79
79
* predictable iteration order. A snapshot of the keys and entries may be
80
80
* obtained in ascending and descending order of retention.
@@ -447,8 +447,8 @@ void drainWriteBuffer() {
447
447
}
448
448
449
449
/**
450
- * Attempts to transition the node from the <tt> alive</tt> state to the
451
- * <tt> retired</tt> state.
450
+ * Attempts to transition the node from the {@code alive} state to the
451
+ * {@code retired} state.
452
452
*
453
453
* @param node the entry in the page replacement policy
454
454
* @param expect the expected weighted value
@@ -463,8 +463,8 @@ boolean tryToRetire(Node<K, V> node, WeightedValue<V> expect) {
463
463
}
464
464
465
465
/**
466
- * Atomically transitions the node from the <tt> alive</tt> state to the
467
- * <tt> retired</tt> state, if a valid transition.
466
+ * Atomically transitions the node from the {@code alive} state to the
467
+ * {@code retired} state, if a valid transition.
468
468
*
469
469
* @param node the entry in the page replacement policy
470
470
*/
@@ -482,8 +482,8 @@ void makeRetired(Node<K, V> node) {
482
482
}
483
483
484
484
/**
485
- * Atomically transitions the node to the <tt> dead</tt> state and decrements
486
- * the <tt> weightedSize</tt> .
485
+ * Atomically transitions the node to the {@code dead} state and decrements
486
+ * the {@code weightedSize} .
487
487
*
488
488
* @param node the entry in the page replacement policy
489
489
*/
@@ -895,7 +895,7 @@ public void setNext(Node<K, V> next) {
895
895
this .next = next ;
896
896
}
897
897
898
- /** Retrieves the value held by the current <tt> WeightedValue</tt> . */
898
+ /** Retrieves the value held by the current {@code WeightedValue} . */
899
899
V getValue () {
900
900
return get ().value ;
901
901
}
@@ -1168,7 +1168,7 @@ public Builder() {
1168
1168
}
1169
1169
1170
1170
/**
1171
- * Specifies the initial capacity of the hash table (default <tt>16</tt> ).
1171
+ * Specifies the initial capacity of the hash table (default {@code 16} ).
1172
1172
* This is the number of key-value pairs that the hash table can hold
1173
1173
* before a resize operation is required.
1174
1174
*
@@ -1198,7 +1198,7 @@ public Builder<K, V> maximumCapacity(long capacity) {
1198
1198
/**
1199
1199
* Specifies the estimated number of concurrently updating threads. The
1200
1200
* implementation performs internal sizing to try to accommodate this many
1201
- * threads (default <tt>16</tt> ).
1201
+ * threads (default {@code 16} ).
1202
1202
*
1203
1203
* @param concurrencyLevel the estimated number of concurrently updating
1204
1204
* threads
0 commit comments