Peta / cache berbasis waktu Java dengan kunci kedaluwarsa [ditutup]

Apakah ada di antara Anda yang tahu tentang Java Map atau penyimpanan data standar serupa yang secara otomatis membersihkan entri setelah batas waktu tertentu? Ini berarti penuaan, di mana entri yang sudah kadaluwarsa “usang” secara otomatis.

Lebih disukai di perpustakaan sumber terbuka yang dapat diakses melalui Maven?

Saya tahu cara untuk menerapkan fungsi sendiri dan telah melakukannya beberapa kali di masa lalu, jadi saya tidak meminta saran dalam hal itu, tetapi untuk petunjuk penerapan referensi yang baik.

Solusi berbasis WeakReference seperti WeakHashMap bukan pilihan, karena kunci saya cenderung bukan string yang diinternir dan saya ingin batas waktu yang dapat dikonfigurasi yang tidak bergantung pada pengumpul sampah.

Ehcache juga merupakan opsi yang tidak ingin saya andalkan karena memerlukan file konfigurasi eksternal. Saya mencari solusi hanya kode.

Iya. Google Collections, atau Jambu seperti namanya sekarang memiliki sesuatu yang disebut MapMaker yang dapat melakukan hal itu.

ConcurrentMap<Key, Graph> graphs = new MapMaker()
   .concurrencyLevel(4)
   .softKeys()
   .weakValues()
   .maximumSize(10000)
   .expiration(10, TimeUnit.MINUTES)
   .makeComputingMap(
       new Function<Key, Graph>() {
         public Graph apply(Key key) {
           return createExpensiveGraph(key);
         }
       });

Memperbarui:

Pada jambu 10.0 (dirilis 28 September 2011) banyak dari metode MapMaker ini telah ditinggalkan demi CacheBuilder baru :

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(
        new CacheLoader<Key, Graph>() {
          public Graph load(Key key) throws AnyException {
            return createExpensiveGraph(key);
          }
        });

Ini adalah contoh implementasi yang saya lakukan untuk persyaratan dan konkurensi yang sama berfungsi dengan baik. Mungkin bermanfaat bagi seseorang.

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 
 * @author Vivekananthan M
 *
 * @param <K>
 * @param <V>
 */
public class WeakConcurrentHashMap<K, V> extends ConcurrentHashMap<K, V> {

    private static final long serialVersionUID = 1L;

    private Map<K, Long> timeMap = new ConcurrentHashMap<K, Long>();
    private long expiryInMillis = 1000;
    private static final SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss:SSS");

    public WeakConcurrentHashMap() {
        initialize();
    }

    public WeakConcurrentHashMap(long expiryInMillis) {
        this.expiryInMillis = expiryInMillis;
        initialize();
    }

    void initialize() {
        new CleanerThread().start();
    }

    @Override
    public V put(K key, V value) {
        Date date = new Date();
        timeMap.put(key, date.getTime());
        System.out.println("Inserting : " + sdf.format(date) + " : " + key + " : " + value);
        V returnVal = super.put(key, value);
        return returnVal;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        for (K key : m.keySet()) {
            put(key, m.get(key));
        }
    }

    @Override
    public V putIfAbsent(K key, V value) {
        if (!containsKey(key))
            return put(key, value);
        else
            return get(key);
    }

    class CleanerThread extends Thread {
        @Override
        public void run() {
            System.out.println("Initiating Cleaner Thread..");
            while (true) {
                cleanMap();
                try {
                    Thread.sleep(expiryInMillis / 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void cleanMap() {
            long currentTime = new Date().getTime();
            for (K key : timeMap.keySet()) {
                if (currentTime > (timeMap.get(key) + expiryInMillis)) {
                    V value = remove(key);
                    timeMap.remove(key);
                    System.out.println("Removing : " + sdf.format(new Date()) + " : " + key + " : " + value);
                }
            }
        }
    }
}

Git Repo Link (Dengan Implementasi Pendengar)

https://github.com/vivekjustthink/WeakConcurrentHashMap

Bersulang!!

Anda dapat mencoba implementasi saya dari peta hash yang kedaluwarsa. Implementasi ini tidak menggunakan utas untuk menghapus entri yang kadaluwarsa, melainkan menggunakan DelayQueue yang dibersihkan di setiap operasi secara otomatis.

Apache Commons memiliki dekorator untuk Peta untuk kedaluwarsa entri: PassiveExpiringMap Ini lebih sederhana daripada cache dari Guava.

PS berhati-hatilah, itu tidak disinkronkan.

Kedengarannya seperti ehcache terlalu banyak untuk apa yang Anda inginkan, tetapi perhatikan bahwa itu tidak memerlukan file konfigurasi eksternal.

Pada umumnya ide yang baik untuk memindahkan konfigurasi ke file konfigurasi deklaratif (jadi Anda tidak perlu mengkompilasi ulang ketika instalasi baru memerlukan waktu kedaluwarsa yang berbeda), tetapi sama sekali tidak diperlukan, Anda masih dapat mengonfigurasinya secara terprogram. http://www.ehcache.org/documentation/user-guide/configuration

Koleksi Google (jambu) memiliki MapMaker di mana Anda dapat mengatur batas waktu (untuk kedaluwarsa) dan Anda dapat menggunakan referensi lunak atau lemah saat Anda memilih menggunakan metode pabrik untuk membuat contoh pilihan Anda.

Anda dapat mencoba Peta Kedaluwarsa http://www.java2s.com/Code/Java/Collections-Data-Structure/ExpiringMap.htm kelas dari Proyek Apache MINA

Jika ada yang membutuhkan hal yang sederhana, mengikuti adalah himpunan kunci yang kedaluwarsa. Mungkin mudah dikonversi ke peta.

public class CacheSet<K> {
    public static final int TIME_OUT = 86400 * 1000;

    LinkedHashMap<K, Hit> linkedHashMap = new LinkedHashMap<K, Hit>() {
        @Override
        protected boolean removeEldestEntry(Map.Entry<K, Hit> eldest) {
            final long time = System.currentTimeMillis();
            if( time - eldest.getValue().time > TIME_OUT) {
                Iterator<Hit> i = values().iterator();

                i.next();
                do {
                    i.remove();
                } while( i.hasNext() && time - i.next().time > TIME_OUT );
            }
            return false;
        }
    };


    public boolean putIfNotExists(K key) {
        Hit value = linkedHashMap.get(key);
        if( value != null ) {
            return false;
        }

        linkedHashMap.put(key, new Hit());
        return true;
    }

    private static class Hit {
        final long time;


        Hit() {
            this.time = System.currentTimeMillis();
        }
    }
}

Biasanya, cache harus menyimpan objek di sekitar waktu tertentu dan akan mengeksposnya beberapa saat kemudian. Apa waktu yang baik untuk mengadakan suatu objek tergantung pada kasus penggunaan. Saya ingin hal ini menjadi sederhana, tanpa utas atau penjadwal. Pendekatan ini bekerja untuk saya. Tidak seperti SoftReferences, objek dijamin akan tersedia dalam jumlah waktu minimum. Namun, jangan tinggal di dalam memori sampai matahari berubah menjadi raksasa merah .

Sebagai contoh penggunaan, pikirkan sistem yang merespons secara lambat yang harus dapat memeriksa apakah permintaan telah dilakukan baru-baru ini, dan dalam hal ini jangan melakukan tindakan yang diminta dua kali, bahkan jika pengguna yang sibuk menekan tombol beberapa kali. Tetapi, jika tindakan yang sama diminta beberapa waktu kemudian, itu akan dilakukan lagi.

class Cache<T> {
    long avg, count, created, max, min;
    Map<T, Long> map = new HashMap<T, Long>();

    /**
     * @param min   minimal time [ns] to hold an object
     * @param max   maximal time [ns] to hold an object
     */
    Cache(long min, long max) {
        created = System.nanoTime();
        this.min = min;
        this.max = max;
        avg = (min + max) / 2;
    }

    boolean add(T e) {
        boolean result = map.put(e, Long.valueOf(System.nanoTime())) != null;
        onAccess();
        return result;
    }

    boolean contains(Object o) {
        boolean result = map.containsKey(o);
        onAccess();
        return result;
    }

    private void onAccess() {
        count++;
        long now = System.nanoTime();
        for (Iterator<Entry<T, Long>> it = map.entrySet().iterator(); it.hasNext();) {
            long t = it.next().getValue();
            if (now > t + min && (now > t + max || now + (now - created) / count > t + avg)) {
                it.remove();
            }
        }
    }
}

Cache jambu biji mudah diimplementasikan. Kami dapat kedaluwarsa pada basis waktu menggunakan cache jambu biji. Saya telah membaca sepenuhnya posting dan di bawah ini memberikan kunci studi saya.

cache = CacheBuilder.newBuilder().refreshAfterWrite(2,TimeUnit.SECONDS).
              build(new CacheLoader<String, String>(){
                @Override
                public String load(String arg0) throws Exception {
                    // TODO Auto-generated method stub
                    return addcache(arg0);
                }

              }

Referensi: contoh cache jambu biji