AsyncTtlIMaps.java

package com.hazelcast.util;

import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;
import com.hazelcast.core.LifecycleEvent;
import com.hazelcast.core.LifecycleListener;
import com.hazelcast.core.LifecycleService;

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;


/**
 * For creating AsyncTtlIMaps, given (optional) HazelcastInstance, a map
 * name, and an (optional) ExecutorService. If ExecutorService is passed,
 * specify whether it should be shutdown with the HazelcastInstance.
 */
public final class AsyncTtlIMaps {

    public static <K, V> AsyncTtlIMap<K, V> getMap(String name) {
        return getMap(Hazelcast.getDefaultInstance(), name);
    }

    public static <K, V> AsyncTtlIMap<K, V> getMap(
            String name,
            final ExecutorService exec,
            boolean shutdownWithHazelcast) {
        return getMap(Hazelcast.getDefaultInstance(), name, exec, shutdownWithHazelcast);
    }

    public static <K, V> AsyncTtlIMap<K, V> getMap(
            HazelcastInstance hazelcast,
            String name) {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        return getMap(hazelcast, name, exec, true);
    }

    public static <K, V> AsyncTtlIMap<K, V> getMap(
            HazelcastInstance hazelcast,
            String name,
            final ExecutorService exec,
            boolean shutdownWithHazelcast) {

        if (shutdownWithHazelcast) {
            hazelcast.getLifecycleService().addLifecycleListener(new LifecycleListener() {
                public void stateChanged(LifecycleEvent event) {
                    switch (event.getState()) {
                        case SHUTDOWN:
                            exec.shutdown();
                            break;
                        default:
                            break;
                    }
                }
            });
        }

        IMap<K, V> map = hazelcast.getMap(name);
        return new Impl<K, V>(map, exec);
    }


    static class Impl<K, V> extends ForwardingIMap<K, V> implements AsyncTtlIMap<K, V> {

        Impl(IMap<K, V> map, ExecutorService exec) {
            super(map);
            this.exec = exec;
        }

        @Override public Future<V> putAsync(final K key, final V value,
                                            final long ttl, final TimeUnit timeunit) {
            return exec.submit(new Callable<V>() {
                public V call() {
                    return delegate().put(key, value, ttl, timeunit);
                }
            });
        }

        private final ExecutorService exec;
    }

    private AsyncTtlIMaps() { /* uninstantiable */ }
}