java定时开启缓存_Java实现单机定时缓存

import java.io.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

*使用DelayQueue和ConcurrentMap实现单机定时缓存

*/

class Demo4 {

public static void main(String[] args) throws InterruptedException {

Cache cache = new Cache();

cache.put(1, "aaaa", 3, TimeUnit.SECONDS);

Thread.sleep(1000 * 2);

{

String str = cache.get(1);

System.out.println(str);

}

//超时

Thread.sleep(1000 * 2);

{

String str = cache.get(1);

System.out.println(str);

}

}

}

class Pair {

public K first;

public V second;

public Pair() {

}

public Pair(K first, V second) {

this.first = first;

this.second = second;

}

}

class DelayItem implements Delayed {

/**

* Base of nanosecond timings, to avoid wrapping

*/

private static final long NANO_ORIGIN = System.nanoTime();

/**

* Returns nanosecond time offset by origin

*/

final static long now() {

return System.nanoTime() - NANO_ORIGIN;

}

/**

* Sequence number to break scheduling ties, and in turn to guarantee FIFO order among tied

* entries.

*/

private static final AtomicLong sequencer = new AtomicLong(0);

/**

* Sequence number to break ties FIFO

*/

private final long sequenceNumber;

/**

* The time the task is enabled to execute in nanoTime units

*/

private final long time;

private final T item;

public DelayItem(T submit, long timeout) {

this.time = now() + timeout;

this.item = submit;

this.sequenceNumber = sequencer.getAndIncrement();

}

public T getItem() {

return this.item;

}

@Override

public long getDelay(TimeUnit unit) {

long d = unit.convert(time - now(), TimeUnit.NANOSECONDS);

return d;

}

@Override

public int compareTo(Delayed other) {

if (other == this) { // compare zero ONLY if same object

return 0;

}

if (other instanceof DelayItem) {

DelayItem x = (DelayItem) other;

long diff = time - x.time;

if (diff < 0) {

return -1;

} else if (diff > 0) {

return 1;

} else if (sequenceNumber < x.sequenceNumber) {

return -1;

} else {

return 1;

}

}

long d = (getDelay(TimeUnit.NANOSECONDS) - other.getDelay(TimeUnit.NANOSECONDS));

return (d == 0) ? 0 : ((d < 0) ? -1 : 1);

}

}

class Cache {

private static final Logger LOG = Logger.getLogger(Cache.class.getName());

private ConcurrentMap cacheObjMap = new ConcurrentHashMap();

private DelayQueue>> q = new DelayQueue>>();

private Thread daemonThread;

public Cache() {

Runnable daemonTask = new Runnable() {

@Override

public void run() {

daemonCheck();

}

};

daemonThread = new Thread(daemonTask);

daemonThread.setDaemon(true);

daemonThread.setName("Cache Daemon");

daemonThread.start();

}

private void daemonCheck() {

if (LOG.isLoggable(Level.INFO)) {

LOG.info("cache service started.");

}

for (; ; ) {

try {

DelayItem> delayItem = q.take();

if (delayItem != null) {

// 超时对象处理

Pair pair = delayItem.getItem();

cacheObjMap.remove(pair.first, pair.second); // compare and remove

}

} catch (InterruptedException e) {

if (LOG.isLoggable(Level.SEVERE)) {

LOG.log(Level.SEVERE, e.getMessage(), e);

}

break;

}

}

if (LOG.isLoggable(Level.INFO)) {

LOG.info("cache service stopped.");

}

}

// 添加缓存对象

public void put(K key, V value, long time, TimeUnit unit) {

V oldValue = cacheObjMap.put(key, value);

if (oldValue != null) {

q.remove(key);

}

long nanoTime = TimeUnit.NANOSECONDS.convert(time, unit);

q.put(new DelayItem>(new Pair(key, value), nanoTime));

}

public V get(K key) {

return cacheObjMap.get(key);

}

}