シンプルLRUキャッシュアルゴリズム

   以下に示すように、最も単純なLRUアルゴリズムは、のLinkedHashMap JDK、前記オーバーライドremoveEldestEntry（のMap.Entry）メソッドを使用することです。

Javaコード

 

1. 輸入はjava.util.ArrayList;  
2. インポートのjava.util.Collection;  
3. インポートJawakutilklaidakedःashanap。  
4. 輸入java.util.concurrent.locks.Lock。  
5. 輸入java.util.concurrent.locks.ReentrantLock。  
6. 輸入java.util.Map;  
7.   
8.   
9. / ** 
10.  *クラス説明：キャッシュのLinkedHashMap簡単な使用は、JDKのドキュメントを参照してください、removeEldestEntry方法の詳細を実現する必要があります 
11.  *  
12.  * @authorデニス 
13.  *  
14.  * @param <K> 
15.  * @param <V> 
16.  * /  
17. パブリック  クラスLRULinkedHashMap <K、Vは>  のLinkedHashMap <K、V>を{延び  
18.     民間  最終  int型MAXCAPACITY。  
19.   
20.     プライベート  静的な  最終  フロートDEFAULT_LOAD_FACTOR =  0.75F;  
21.   
22.     民間  最終ロックロック=  新しいReentrantLockの（）;  
23.   
24.     公共LRULinkedHashMap（MAXCAPACITYをINT）{  
25.         スーパー（MAXCAPACITY、DEFAULT_LOAD_FACTOR、  真の）;  
26.         this.maxCapacity = MAXCAPACITY。  
27.     }  
28.   
29.     @オーバーライド  
30.     保護された  ブールremoveEldestEntry（java.util.Map.Entry <K、V>長男）{  
31.         リターンの大きさ（）> MAXCAPACITY。  
32.     }  
33.     @オーバーライド  
34.     パブリック  ブールのcontainsKey（オブジェクトキー）{  
35.         {試します  
36.             lock.lock（）;  
37.             返す  super.containsKey（キー）。  
38.         }  最後に{  
39.             施錠開錠（）;  
40.         }  
41.     }  
42.   
43.       
44.     @オーバーライド  
45.     パブリックVの取得（オブジェクトキー）{  
46.         {試します  
47.             lock.lock（）;  
48.             リターン  super.get（キー）;  
49.         }  最後に{  
50.             施錠開錠（）;  
51.         }  
52.     }  
53.   
54.     @オーバーライド  
55.     パブリックVプット（Kキー、V値）{  
56.         {試します  
57.             lock.lock（）;  
58.             リターン  super.put（キー、値）;  
59.         }  最後に{  
60.             施錠開錠（）;  
61.         }  
62.     }  
63.   
64.     公共  int型のサイズ（）{  
65.         {試します  
66.             lock.lock（）;  
67.             リターン  super.size（）;  
68.         }  最後に{  
69.             施錠開錠（）;  
70.         }  
71.     }  
72.   
73.     公共  のボイドをクリア（）{  
74.         {試します  
75.             lock.lock（）;  
76.             super.clear（）;  
77.         }  最後に{  
78.             施錠開錠（）;  
79.         }  
80.     }  
81.   
82.     パブリックコレクション<のMap.Entry <K、V >>のgetAll（）{  
83.         {試します  
84.             lock.lock（）;  
85.             返す  新しいのArrayList <のMap.Entry <K、V >>（super.entrySet（））;  
86.         }  最後に{  
87.             施錠開錠（）;  
88.         }  
89.     }  
90. }  
91.     

  あなたが見たソースコードのLinkedHashMapを見れば、LRUアルゴリズムでは、位置がリストの先頭に直接ヘッド位置調整に、新しいコンテンツをリストポイントの位置を調整することにより、ヒットする二重リンクリスト、この方法で実装されています最近、リストの先頭にコンテンツの移動を襲ってきた、我々は、交換する最後の位置が最低使用の場所で一覧表示する必要があります。
    LRUアルゴリズムはまた、タイムスタンプへのアクセスに関連して実施され、最小カウント位置を検索と置換交換時にヒットカウンタがインクリメントされるバッファ記憶が設けられている位置カウンタをカウントすることによって達成することができます。このアルゴリズムは、明らかに、最小時間計算の位置を見つけるためのトラバースカウントはO（n）がシーンをキャッシュされた少量のデータのために適しています。私は、最小カウントがMINI_ACESSより大きい場合、アクセスタイムスタンプの組み合わせを実現し、最も古いエントリがアクセスされていないが削除されます。

Javaコード

 

1. インポートしたjava.io.Serializable;  
2. 輸入はjava.util.ArrayList;  
3. インポートのjava.util.Collection;  
4. 輸入java.util.HashMapを;  
5. インポートするjava.util.Iterator;  
6. 輸入java.util.Map;  
7. 輸入java.util.Set;  
8. 輸入java.util.concurrent.atomic.AtomicInteger。  
9. 輸入java.util.concurrent.atomic.AtomicLong;  
10. 輸入java.util.concurrent.locks.Lock。  
11. 輸入java.util.concurrent.locks.ReentrantLock。  
12.   
13. / ** 
14.  *  
15.  * @authorデニス  
16.  従来のLRUアルゴリズム際に小さなキャッシュの数、カウントによってのみキャッシュ：*クラス説明 
17.  * @param <K> 
18.  * @param <V> 
19.  * /  
20. パブリック  クラスLRUCache <K、V>  実装シリアライズ{  
21.   
22.     プライベート  静的  最終  int型のDEFAULT_CAPACITY =  100;  
23.   
24.     保護された地図<K、ValueEntry>マップ。  
25.   
26.     民間  最終ロックロック=  新しいReentrantLockの（）;  
27.   
28.     民間  最終  過渡  int型のMAXCAPACITY。  
29.   
30.     プライベート  静的な  int型のMINI_ACCESS =  10;  
31.   
32.     パブリックLRUCache（）{  
33.         この（DEFAULT_CAPACITY）。  
34.     }  
35.   
36.     公共LRUCache（INT容量）{  
37.         IF（容量<=  0）  
38.             スロー  新しい新しいのRuntimeException（「0未満ではないのバッファ容量」）;  
39.         this.maxCapacity =能力;  
40.         this.map =  新規のHashMap <K、ValueEntry>（MAXCAPACITY）。  
41.     }  
42.   
43.     パブリック  ブールにContainsKey（Kキー）{  
44.         {試します  
45.             lock.lock（）;  
46.             返す  this.map.containsKey（キー）。  
47.         }  最後に{  
48.             施錠開錠（）;  
49.         }  
50.     }  
51.   
52.     パブリックVプット（Kキー、V値）{  
53.         {試します  
54.             lock.lock（）;  
55.             - （（map.size（）> MAXCAPACITY場合は  {1）&& map.containsKey（キー）！）  
56.                 //するSystem.out.println（ "スタート"）;  
57.                 設定<のMap.Entry <K、ValueEntry >>エントリ=  this.map.entrySet（）。  
58.                 removeRencentlyLeastAccess（エントリ）。  
59.             }  
60.             ValueEntry valueEntry = map.put（キー、  新しいValueEntry（値））;  
61.             （valueEntry！=の場合  はnull）  
62.                 valueEntry.valueを返します。  
63.             他  
64.                 リターン  NULL;  
65.         }  最後に{  
66.             施錠開錠（）;  
67.         }  
68.     }  
69.   
70.     / ** 
71.      *最も最近アクセスを削除します 
72.      * /  
73.     保護された  無効removeRencentlyLeastAccess（  
74.             設定<のMap.Entry <K、ValueEntry >>エントリ）{  
75.         //使用の最小周波数  
76.         少なくともint型=  0;  
77.         //最長アクセスされません  
78.         長い早い=  0;  
79.         K toBeRemovedByCount =  NULL;  
80.         K toBeRemovedByTime =  NULL;  
81.         反復子<のMap.Entry <K、ValueEntry >>それは（entries.iteratorを=）。  
82.         IF（it.hasNext（））{  
83.             Map.Entry <K、ValueEntry> valueEntry = it.next（）。  
84.             最低= valueEntry.getValue（）count.get（）。  
85.             toBeRemovedByCount = valueEntry.getKey（）。  
86.             最も早い= valueEntry.getValue（）lastAccess.get（）。  
87.             toBeRemovedByTime = valueEntry.getKey（）。  
88.         }  
89.         一方、（it.hasNext（））{  
90.             Map.Entry <K、ValueEntry> valueEntry = it.next（）。  
91.             IF（valueEntry.getValue（）。count.get（）<最低）{  
92.                 最低= valueEntry.getValue（）count.get（）。  
93.                 toBeRemovedByCount = valueEntry.getKey（）。  
94.             }  
95.             IF（valueEntry.getValue（）。lastAccess.get（）<最古）{  
96.                 。最も早い= valueEntry.getValue（）count.get（）;  
97.                 toBeRemovedByTime = valueEntry.getKey（）。  
98.             }  
99.         }  
100.         //するSystem.out.println（ "削除：" + toBeRemovedを）。  
101.         数が最も使用MINI_ACCESSよりも大きい場合は、//、そして最も初期のアイテムのアクセス時間を削除する（つまり、アイテムが最長にアクセスしていません）  
102.         もし（少なくとも> MINI_ACCESS）{  
103.             map.remove（toBeRemovedByTime）。  
104.         }  他{  
105.             map.remove（toBeRemovedByCount）。  
106.         }  
107.     }  
108.   
109.     パブリックVのGET（Kキー）{  
110.         {試します  
111.             lock.lock（）;  
112.             V値=  NULL;  
113.             ValueEntry valueEntry = map.get（キー）。  
114.             もし（valueEntry！=  NULL）{  
115.                 //更新アクセスタイムスタンプ  
116.                 valueEntry.updateLastAccess（）;  
117.                 //更新訪問  
118.                 valueEntry.count.incrementAndGet（）;  
119.                 値= valueEntry.value。  
120.             }  
121.             値を返します。  
122.         }  最後に{  
123.             施錠開錠（）;  
124.         }  
125.     }  
126.   
127.     公共  のボイドをクリア（）{  
128.         {試します  
129.             lock.lock（）;  
130.             map.clear（）;  
131.         }  最後に{  
132.             施錠開錠（）;  
133.         }  
134.     }  
135.   
136.     公共  int型のサイズ（）{  
137.         {試します  
138.             lock.lock（）;  
139.             map.sizeを返します（）;  
140.         }  最後に{  
141.             施錠開錠（）;  
142.         }  
143.     }  
144.   
145.     パブリックコレクション<のMap.Entry <K、V >>のgetAll（）{  
146.         {試します  
147.             lock.lock（）;  
148.             設定<K>キー= map.keySet（）。  
149.             地図<K、V> TMP =  新規のHashMap <K、V>（）;  
150.             {（鍵Kキー）のために  
151.                 tmp.put（キー、map.get（キー）.VALUE）。  
152.             }  
153.             返す  新しいのArrayList <のMap.Entry <K、V >>（tmp.entrySet（））;  
154.         }  最後に{  
155.             施錠開錠（）;  
156.         }  
157.     }  
158.   
159.     クラスValueEntryは  {Serializableを実装します  
160.         プライベートV値。  
161.   
162.         民間のAtomicInteger数;  
163.   
164.         プライベートAtomicLong lastAccess。  
165.   
166.         公共ValueEntry（V値）{  
167.             this.value =値。  
168.             this.count =  新規のAtomicInteger（0）。  
169.             lastAccess =  新しいAtomicLong（System.nanoTimeの（））;  
170.         }  
171.           
172.         公共  ボイドupdateLastAccess（）{  
173.             this.lastAccess.set（System.nanoTimeの（））。  
174.         }  
175.   
176.     }  
177. }  

ます。https：//www.cnblogs.com/wangzehuaw/p/4318038.htmlで再現