@@ -26,9 +26,9 @@ public static interface ExpiredCallback<K, V> {
26
26
27
27
private LinkedList <HashMap <K , V >> _buckets ;
28
28
29
+ private final Object _lock = new Object ();
29
30
private Thread _cleaner ;
30
31
private ExpiredCallback _callback ;
31
- private final Object _lock = new Object ();
32
32
33
33
public TimeCacheMap (int expirationSecs , int numBuckets , ExpiredCallback <K , V > callback ) {
34
34
if (numBuckets <2 ) {
@@ -39,6 +39,7 @@ public TimeCacheMap(int expirationSecs, int numBuckets, ExpiredCallback<K, V> ca
39
39
_buckets .add (new HashMap <K , V >());
40
40
}
41
41
42
+
42
43
_callback = callback ;
43
44
final long expirationMillis = expirationSecs * 1000L ;
44
45
final long sleepTime = expirationMillis / (numBuckets -1 );
@@ -81,53 +82,61 @@ public TimeCacheMap(int expirationSecs, int numBuckets) {
81
82
82
83
83
84
public boolean containsKey (K key ) {
84
- for (HashMap <K , V > bucket : _buckets ) {
85
- if (bucket .containsKey (key )) {
86
- return true ;
85
+ synchronized (_lock ) {
86
+ for (HashMap <K , V > bucket : _buckets ) {
87
+ if (bucket .containsKey (key )) {
88
+ return true ;
89
+ }
87
90
}
91
+ return false ;
88
92
}
89
- return false ;
90
93
}
91
94
92
95
public V get (K key ) {
93
- for (HashMap <K , V > bucket : _buckets ) {
94
- if (bucket .containsKey (key )) {
95
- return bucket .get (key );
96
+ synchronized (_lock ) {
97
+ for (HashMap <K , V > bucket : _buckets ) {
98
+ if (bucket .containsKey (key )) {
99
+ return bucket .get (key );
100
+ }
96
101
}
102
+ return null ;
97
103
}
98
- return null ;
99
104
}
100
105
101
106
public void put (K key , V value ) {
102
- Iterator <HashMap <K , V >> it = _buckets .iterator ();
103
- HashMap <K , V > bucket = it .next ();
104
- bucket .put (key , value );
105
- while (it .hasNext ()) {
106
- bucket = it .next ();
107
- bucket .remove (key );
107
+ synchronized (_lock ) {
108
+ Iterator <HashMap <K , V >> it = _buckets .iterator ();
109
+ HashMap <K , V > bucket = it .next ();
110
+ bucket .put (key , value );
111
+ while (it .hasNext ()) {
112
+ bucket = it .next ();
113
+ bucket .remove (key );
114
+ }
108
115
}
109
116
}
110
117
111
-
112
118
public Object remove (K key ) {
113
- for (HashMap <K , V > bucket : _buckets ) {
114
- if (bucket .containsKey (key )) {
115
- return bucket .remove (key );
119
+ synchronized (_lock ) {
120
+ for (HashMap <K , V > bucket : _buckets ) {
121
+ if (bucket .containsKey (key )) {
122
+ return bucket .remove (key );
123
+ }
116
124
}
125
+ return null ;
117
126
}
118
- return null ;
119
127
}
120
128
121
129
public int size () {
122
- int size = 0 ;
123
- for (HashMap <K , V > bucket : _buckets ) {
124
- size +=bucket .size ();
130
+ synchronized (_lock ) {
131
+ int size = 0 ;
132
+ for (HashMap <K , V > bucket : _buckets ) {
133
+ size +=bucket .size ();
134
+ }
135
+ return size ;
125
136
}
126
- return size ;
127
137
}
128
-
138
+
129
139
public void cleanup () {
130
140
_cleaner .interrupt ();
131
- }
132
-
141
+ }
133
142
}
0 commit comments