woodwhales's blog

import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.validation.Valid;

/**
 * @author woodwhales
 * @date 2020-12-26 17:17
 */
@Service
@Validated
public class TempServiceImpl implements TempService {

    @Override
    public void save(@Valid TempData tempData) {
        System.out.println(tempData);
    }

}

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * @author woodwhales
 * @date 2020-12-26 17:18
 */
@Data
public class TempData {

    @NotNull
    private Integer id;

    @NotBlank
    private String name;

}

@RestController
public class TemController {

    @Autowired
    private TempService tempService;

    @GetMapping("/temp")
    public void temp() {
        tempService.save(new TempData());
    }
}

// 第一种 直接返回user本身
Map<Long, User> map = userList.stream().collect(Collectors.toMap(User::getId, user -> user));

// 第二种 Function中有一个static方法identity 返回本身
Map<Long, User> map = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

// 如果list中的age存在相同的时候,转化map的时候就会出错Duplicate key
// toMap的重载,定义key2覆盖key1的值
Map<Integer, Users> map3 = list.stream().collect(Collectors.toMap(Users::getId, Function.identity(), (key1,key2) -> key2));

public class DataTool {

    /**
     * list 转 map 集合
     * @param source 数据源集合
     * @param keyMapper map 集合中的 key 获取规则
     * @param valueMapper map 集合中的 value 获取规则
     * @param <K> map 集合中的 key 类型
     * @param <S> 数据源集合中元素的类型
     * @param <T> map 集合中的 value 类型
     * @return
     */
    public static <K, S, T> Map<K,T> toMap(List<S> source,
                                           Function<? super S, ? extends K> keyMapper,
                                           Function<? super S, ? extends T> valueMapper) {
        if(null == source || source.size() == 0) {
            return Collections.emptyMap();
        }

        return source.stream().collect(Collectors.toMap(keyMapper, valueMapper));
    }
}

Map<String, List<User>> group = list.stream().collect(Collectors.groupingBy(User::getType));

public class DataTool {

    /**
     * 将 list 集合分组
     * @param source 数据源集合
     * @param classifier 分组规则
     * @param <K> map 集合中的 key 类型
     * @param <S> map 集合中的 value 类型
     * @return
     */
    public static <K, S> Map<K, List<S>> groupingBy(List<S> source,
                                                    Function<? super S, ? extends K> classifier) {
        if(null == source || source.size() == 0) {
            return Collections.emptyMap();
        }

        return source.stream().collect(Collectors.groupingBy(classifier));
    }
}

public class DataTool {
    /**
     * 对集合数据进行去重器
     * 非线程安全
     * @param source 数据源集合
     * @param deduplicateInterface 去重器接口
     * @param <K> 去重属性的类型
     * @param <T> 数据源集合中元素的类型
     * @return
     */
    public static <K, T> DeduplicateResult<T> deduplicate(List<T> source,
                                                          DeduplicateInterface<K, T> deduplicateInterface) {
        if(null == source || source.size() == 0) {
            return new DeduplicateResult<T>(source, emptyList(), emptyList(), emptyList());
        }

        Map<K, T> container =  new LinkedHashMap<>();
        // 无效的数据集合
        List<T> invalidList = new LinkedList<>();
        // 重复的数据集合
        List<T> repetitiveList = new LinkedList<>();

        for (T data : source) {
            if (!deduplicateInterface.isValid(data)) {
                invalidList.add(data);
            } else {
                K deduplicatedKey = deduplicateInterface.getDeduplicatedKey(data);
                T putData = container.put(deduplicatedKey, data);
                if(Objects.nonNull(putData)) {
                    repetitiveList.add(putData);
                }
            }
        }

        // 已去重的数据集合
        List<T> deduplicatedList = new ArrayList<>(container.values());

        return new DeduplicateResult<T>(source, invalidList, deduplicatedList, repetitiveList);
    }
}

public class DataTool {
    
    /**
     * 枚举转 map 集合
     * @param sourceEnumClass 数据源枚举 Class类
     * @param keyMapper map 集合中的 key 获取规则
     * @param <K> map 集合中的 key 类型
     * @param <T> map 集合中的 value 类型
     * @return
     */
    public static <K, T extends Enum<T>> Map<K, T> enumMap(Class<T> sourceEnumClass,
                                                         Function<? super T, ? extends K> keyMapper) {
        EnumSet<T> enumSet = EnumSet.allOf(sourceEnumClass);
        return enumSet.stream().collect(Collectors.toMap(keyMapper, Function.identity()));
    }
}

import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:08
 * @description:
 */
public class GoogleEventBusListener {

    @Subscribe
    public void method1(String event) {
        System.out.println("GoogleEventBusListener.method1, event = " + event);
    }

    @Subscribe
    public void method2(Integer event) {
        System.out.println("GoogleEventBusListener.method2, event = " + event);
    }
}

import com.google.common.eventbus.EventBus;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:08
 * @description: EventBus 简单示例
 */
public class SimpleEventBusExample {

    public static void main(String[] args) {
        EventBus eventBus = new EventBus();

        // 监听器注册到 eventBus
        eventBus.register(new GoogleEventBusListener());

        // 发送消息
        eventBus.post("this message from eventBus");
        eventBus.post(200);
    }

}

import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:18
 * @description: 父类监听器
 */
public class FatherListener {

    @Subscribe
    public void accept(String event) {
        System.out.println("FatherListener.accept, event = " + event);
    }

    @Subscribe
    public void consume(String event) {
        System.out.println("FatherListener.consume, event = " + event);
    }
}

import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:19
 * @description: 子类监听器
 */
public class ChildListener extends FatherListener {

    @Subscribe
    @Override
    public void accept(String event) {
        System.out.println("ChildListener.accept, event = " + event);
    }

    @Subscribe
    public void consumeTask(String event) {
        System.out.println("ChildListener.consumeTask, event = " + event);
    }
}

import com.google.common.eventbus.EventBus;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:21
 * @description: 多个监听器监听消息
 * 当只注册监听器中的父类中也监听了某些消息的时候，父类的监听方法也会执行。
 * 如果父类的监听方法被子类覆盖监听，则只执行子类监听器的方法
 *
 */
public class MultipleListenerExample {

    public static void main(String[] args) {
        EventBus eventBus = new EventBus();
        // 监听器注册到 eventBus
        eventBus.register(new ChildListener());

        // 发送消息
        eventBus.post("this message from eventBus");
    }
}

import com.google.gson.Gson;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:33
 * @description: 父类事件对象
 */
public class FruitEvent {

    String name;

    public FruitEvent() {

    }

    public FruitEvent(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return new Gson().toJson(this);
    }
}

import com.google.gson.Gson;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:35
 * @description: 子类事件对象
 */
public class AppleEvent extends FruitEvent {

    public AppleEvent() {
    }

    public AppleEvent(String name) {
        super(name);
    }

    @Override
    public String toString() {
        return new Gson().toJson(this);
    }

}

import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:32
 * @description: 一个监听子类对象，一个监听父类对象
 */
public class SimpleListener {

    @Subscribe
    public void acceptFruitEvent(FruitEvent fruitEvent) {
        System.out.println("SimpleListener.acceptFruitEvent => fruitEvent " + fruitEvent);
    }

    @Subscribe
    public void acceptAppleEvent(AppleEvent appleEvent) {
        System.out.println("SimpleListener.acceptAppleEvent => appleEvent " + appleEvent);
    }
}

import com.google.common.eventbus.EventBus;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:32
 * @description: event 如果有父类，此时某个监听器监听的event是这个基类，
 * 那么消息是这个子类的时候，该监听父类的监听器方法也会执行
 */
public class MultipleEventExample {

    public static void main(String[] args) {
        EventBus eventBus = new EventBus();

        eventBus.register(new SimpleListener());

        eventBus.post(new AppleEvent("apple"));

        eventBus.post(new FruitEvent("fruit"));
    }
}

import com.google.common.base.Throwables;
import com.google.common.eventbus.SubscriberExceptionContext;
import com.google.common.eventbus.SubscriberExceptionHandler;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:54
 * @description: 异常处理器
 */
public class MySubscriberExceptionHandler implements SubscriberExceptionHandler {

    @Override
    public void handleException(Throwable exception, SubscriberExceptionContext context) {
        System.out.println("======== handleException start =========");
        System.out.println("exception => " + Throwables.getStackTraceAsString(exception));
        System.out.println("EventBus => " + context.getEventBus());
        System.out.println("Subscriber => " + context.getSubscriber().getClass().getName());
        System.out.println("SubscriberMethod => " + context.getSubscriberMethod());
        System.out.println("======== handleException end =========");
    }
}

import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:49
 * @description:
 */
public class MyListener {

    @Subscribe
    public void method1(Integer sum) {
        System.out.println("MyListener.method1 => " + sum);
    }

    @Subscribe
    public void method2(Integer sum) {
        System.out.println("MyListener.method2 => " + sum);
    }

    @Subscribe
    public void method3(Integer sum) {
        int i = sum / 0;
        System.out.println("MyListener.method3 => " + sum);
    }

}

import com.google.common.eventbus.EventBus;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 22:48
 * @description: 多个监听器同时监听相同消息，其中一个监听器有异常，那么不会影响其他监听器消费消息
 * 可以在EventBus构造函数中传入一个异常处理器，当监听器有异常抛出时，会执行这个异常处理器
 *
 * 思考点：如果异常处理很长时间，会不会导致后面的监听器等待执行
 *
 */
public class ExceptionListenerExample {

    public static void main(String[] args) {

        EventBus eventBus = new EventBus(new MySubscriberExceptionHandler());

        eventBus.register(new MyListener());

        eventBus.post(Integer.MAX_VALUE);
    }
}

import com.google.common.eventbus.DeadEvent;
import com.google.common.eventbus.Subscribe;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 23:05
 * @description:
 */
public class DeadEventListener {

    @Subscribe
    public void handle(DeadEvent deadEvent) {
        System.out.println("DeadEventListener.handle deadEvent => " + deadEvent);
        System.out.println("DeadEventListener.handle event => " + deadEvent.getEvent());
        System.out.println("DeadEventListener.handle source => " + deadEvent.getSource());
    }
}

import com.google.common.eventbus.EventBus;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.2 23:07
 * @description: 监听DeadEvent消息类型，那么可以从这个DeadEvent对象中获取事件源和eventBus
 */
public class DeadEventExample {

    public static void main(String[] args) {
        EventBus eventBus = new EventBus("DEAD-EVENT-BUS");

        eventBus.register(new DeadEventListener());

        eventBus.post("message");
    }
}

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 13:55
 * @description: Bus 接口
 */
public interface MyBus {

    /**
     * 注册到 bus
     * @param subscriber 订阅者
     */
    void register(Object subscriber);

    /**
     * 从bus中取消注册
     * @param subscriber
     */
    void unRegister(Object subscriber);

    /**
     * 发送消息
     * @param event
     */
    void post(Object event);

    /**
     * 发送消息
     * @param event
     * @param topic
     */
    void post(Object event, String topic);


    /**
     * 关闭bus
     */
    void close();

    /**
     * 获取当前bus名称
     * @return
     */
    String getBusName();

}

public class MyEventBus implements MyBus {

    private final MyRegistry registry = new MyRegistry();

    private String busName;

    private static final String DEFAULT_BUS_NAME = "DEFAULT";

    private static final String DEFAULT_TOPIC = "default-topic";

    private final MyDispatcher dispatcher;
    
    public MyEventBus() {
        this(DEFAULT_BUS_NAME, null, MyDispatcher.SEQ_EXECUTOR_SERVICE);
    }

    public MyEventBus(MyEventExceptionHandler eventExceptionHandler) {
        this(DEFAULT_BUS_NAME, eventExceptionHandler, MyDispatcher.SEQ_EXECUTOR_SERVICE);
    }

    public MyEventBus(String busName, MyEventExceptionHandler eventExceptionHandler, Executor executor) {
        if(Objects.isNull(busName) || busName.isEmpty()) {
            busName = DEFAULT_BUS_NAME;
        }
        this.busName = busName;
        this.dispatcher = MyDispatcher.newDispatcher(executor, eventExceptionHandler);
    }
    
    @Override
    public void register(Object subscriber) {
        this.registry.bind(subscriber);
    }

    @Override
    public void unRegister(Object subscriber) {
        this.unRegister(subscriber);
    }

    @Override
    public void post(Object event) {
        this.post(event, DEFAULT_TOPIC);
    }

    @Override
    public void post(Object event, String topic) {
        this.dispatcher.dispatch(this, registry, event, topic);
    }

    @Override
    public void close() {
        this.dispatcher.close();
    }

    @Override
    public String getBusName() {
        return this.busName;
    }
}

import java.lang.reflect.Method;
import java.util.Objects;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 14:33
 * @description: 消息执行器
 */
public class MyDispatcher {

    private final Executor executorService;

    private final MyEventExceptionHandler eventExceptionHandler;

    public static final Executor SEQ_EXECUTOR_SERVICE = SeqExecutorService.INSTANCE;

    public static final Executor PER_THREAD_EXECUTOR_SERVICE = PerThreadExecutorService.INSTANCE;

    private MyDispatcher(Executor executorService, MyEventExceptionHandler eventExceptionHandler) {
        this.executorService = executorService;
        this.eventExceptionHandler = eventExceptionHandler;
    }

    public void dispatch(MyBus bus, MyRegistry registry, Object event, String topic) {
        ConcurrentLinkedQueue<MySubscriber> subscribers = registry.scanSubscriber(topic);
        if(Objects.isNull(subscribers)) {
            if(Objects.nonNull(eventExceptionHandler)) {
                eventExceptionHandler.handle(new IllegalArgumentException(String.format("The topic [%s] not bind yet", topic)),
                        new DefaultMyContext(bus.getBusName(), null, event));
            }

            return;
        }

        // 遍历所有的监听者，拿到对应的事件参数对象，比对消息的事件类型和监听者参数事件类型是否一致
        subscribers.stream().filter(subscriber -> !subscriber.isDisabled())
                .filter(subscriber -> {
                    Method subscribeMethod = subscriber.getSubscribeMethod();
                    Class<?> parameterTypeClass = subscribeMethod.getParameterTypes()[0];
                    return parameterTypeClass.isAssignableFrom(event.getClass());
                })
                .forEach(subscriber -> invokeRealSubscribe(bus, subscriber, event));
    }

    private void invokeRealSubscribe(MyBus bus, MySubscriber subscriber, Object event) {

        Method subscribeMethod = subscriber.getSubscribeMethod();
        Object subscribeObject = subscriber.getSubscribeObject();

        this.executorService.execute(() -> {
            try {
                subscribeMethod.invoke(subscribeObject, event);
            } catch (Exception e) {
                if(Objects.nonNull(this.eventExceptionHandler)) {
                    this.eventExceptionHandler.handle(e, new DefaultMyContext(bus.getBusName(), subscriber, event));
                }
            }
        });
    }


    public static MyDispatcher newDispatcher(Executor executorService, MyEventExceptionHandler eventExceptionHandler) {
        return new MyDispatcher(executorService, eventExceptionHandler);
    }

    public static MyDispatcher newSeqDispatcher(MyEventExceptionHandler eventExceptionHandler) {
        return new MyDispatcher(SEQ_EXECUTOR_SERVICE, eventExceptionHandler);
    }

    public static MyDispatcher newPerThreadDispatcher(MyEventExceptionHandler eventExceptionHandler) {
        return new MyDispatcher(PER_THREAD_EXECUTOR_SERVICE, eventExceptionHandler);
    }

    public void close() {
        if(executorService instanceof ExecutorService) {
            ((ExecutorService) executorService).shutdown();
        }
    }

    private static class SeqExecutorService implements Executor {

        private static final SeqExecutorService INSTANCE = new SeqExecutorService();

        @Override
        public void execute(Runnable command) {
            command.run();
        }
    }

    private static class PerThreadExecutorService implements Executor {

        private static final PerThreadExecutorService INSTANCE = new PerThreadExecutorService();

        @Override
        public void execute(Runnable command) {
            new Thread(command).start();
        }
    }

    public static class DefaultMyContext implements MyEventContext {

        private final String busName;

        private final MySubscriber subscriber;

        private final Object event;

        public DefaultMyContext(String busName, MySubscriber subscriber, Object event) {
            this.busName = busName;
            this.subscriber = subscriber;
            this.event = event;
        }

        @Override
        public String getSource() {
            return this.busName;
        }

        @Override
        public Object getSubscriberObject() {
            return Objects.nonNull(subscriber) ? subscriber.getSubscribeObject() : null;
        }

        @Override
        public Method getSubscribeMethod() {
            return Objects.nonNull(subscriber) ? subscriber.getSubscribeMethod() : null;
        }

        @Override
        public Object getEvent() {
            return this.event;
        }
    }
}

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 14:04
 * @description: 已订阅bus的订阅者容器对象
 */
public class MyRegistry {

    private final ConcurrentHashMap<String, ConcurrentLinkedQueue<MySubscriber>> subscriberContainer = new ConcurrentHashMap<> ();

    /**
     * 绑定
     * @param subscriber
     */
    public void bind(Object subscriber) {
        List<Method> subscriberMethods = getSubscriberMethods(subscriber);
        subscriberMethods.forEach(method -> tireSubscriber(subscriber, method));
    }

    private void tireSubscriber(Object subscriber, Method method) {
        MySubscribe mySubscribe = method.getDeclaredAnnotation(MySubscribe.class);
        String topic = mySubscribe.topic();
        subscriberContainer.computeIfAbsent(topic, key -> new ConcurrentLinkedQueue<>());
        subscriberContainer.get(topic).add(new MySubscriber(subscriber, method));
    }

    private List<Method> getSubscriberMethods(Object subscriber) {
        List<Method> methods = new ArrayList<>();

        Class<?> subscriberClass = subscriber.getClass();
        while (Objects.nonNull(subscriberClass)) {
            Method[] declaredMethods = subscriberClass.getDeclaredMethods();

            Arrays.stream(declaredMethods).filter(method ->
                method.isAnnotationPresent(MySubscribe.class) &&
                        method.getParameterCount() == 1 &&
                        method.getModifiers() == Modifier.PUBLIC
            ).forEach(methods::add);

            // 获取当前 subscriber 的父类
            subscriberClass = subscriberClass.getSuperclass();
        }

        return methods;
    }

    /**
     * 解绑
     * @param subscriber
     */
    public void unBind(Object subscriber) {
        subscriberContainer.forEach((key, queue) -> {
            queue.forEach(subscriberItem -> {
                if(subscriberItem.getSubscribeObject() == subscriber) {
                    subscriberItem.setDisabled(false);
                }
            });
        });
    }

    /**
     * 根据topic获取已经绑定的监听对象
     * @param topic
     * @return
     */
    public ConcurrentLinkedQueue<MySubscriber> scanSubscriber(final String topic) {
        return subscriberContainer.get(topic);
    }

}

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 14:14
 * @description: 异常处理器
 */
public interface MyEventExceptionHandler {

    /**
     * 对 event 异常处理
     * @param cause
     * @param eventContext
     */
    void handle(Throwable cause, MyEventContext eventContext);

}

import java.lang.reflect.Method;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 14:28
 * @description:
 */
public interface MyEventContext {

    String getSource();

    Object getSubscriberObject();

    Method getSubscribeMethod();

    Object getEvent();

}

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 15:00
 * @description: 自定义监听器订阅方法注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MySubscribe {

    String topic() default "default-topic";
}

import java.lang.reflect.Method;

/**
 * @projectName: guava
 * @author: woodwhales
 * @date: 20.7.4 15:05
 * @description: 监听者信息对象
 */
public class MySubscriber {

    private final Object subscribeObject;

    private final Method subscribeMethod;

    private boolean disabled = false;

    public MySubscriber(Object subscribeObject, Method subscribeMethod) {
        this.subscribeObject = subscribeObject;
        this.subscribeMethod = subscribeMethod;
    }

    public Object getSubscribeObject() {
        return subscribeObject;
    }

    public Method getSubscribeMethod() {
        return subscribeMethod;
    }

    public boolean isDisabled() {
        return disabled;
    }

    public void setDisabled(boolean disabled) {
        this.disabled = disabled;
    }
}

Object obj = new Object();

/**
 * 测试强引用
 *
 * 测试时，注意设置JVM参数：-Xms128m -Xmx128m -XX:+PrintGCDetails
 *
 * 因为不断的创建 MyReference 对象，而这些对象是强引用，一直在被 list 维护着，
 * 所以在程序运行期间，就算发生垃圾回收，也不会将list维护的强引用对象回收，
 * 因此堆内存会不断被占用，直到内存溢出。
 *
 * @throws Exception
 */
private static void testStrongReferences() throws Exception {
    List<MyReference> list = new ArrayList<>();

    int index = 1;

    while (true) {
        int currentIndex = index++;
        list.add(new MyReference(currentIndex));
        System.out.println("the index = " + index + " MyReference inserted to list");
        TimeUnit.MILLISECONDS.sleep(500);
    }
}

private static class MyReference {

    private final int index;

    private int[] data = new int[1024 * 1024];

    private MyReference(int index) {
        this.index = index;
    }

    /**
     * Java回收该类的一个对象时，就会调用这个已经被重写的finalize()方法。
     * 标记当前对象在下一次GC的时候会被垃圾回收，如果不想被回收，那么可以重写这个方法，拯救这个对象和 root 强关联。
     * @throws Throwable
     */
    @Override
    protected void finalize() throws Throwable {
        System.out.println("index = [ "+ index +"] will be GC");
    }
}

Object obj = new Object();
ReferenceQueue queue = new ReferenceQueue();
SoftReference reference = new SoftReference(obj, queue);
//强引用对象滞空，保留软引用
obj = null;

SoftReference ref = null;
while ((ref = (SoftReference) queue.poll()) != null) {
    //清除软引用对象
}

/**
 * 软引用测试
 *
 * 测试时，注意设置JVM参数：-Xms128m -Xmx128m -XX:+PrintGCDetails
 *
 * 当内存快要耗尽时，GC 会回收掉软引用。
 *
 * 注意：由于内存占用太快，导致当内存快要耗尽时，GC还没来得及回收掉软引用时，也会出现OOM异常。
 *
 * @throws Exception
 */
public static void testSoftReferences() throws Exception {
    List<SoftReference<MyReference>> list = new ArrayList<>();

    int index = 1;

    while (true) {
        int currentIndex = index++;
        list.add(new SoftReference<>(new MyReference(currentIndex)));
        System.out.println("the index = " + index + " MyReference inserted to list");
        //TimeUnit.MILLISECONDS.sleep(500);
        // 当设置吃内存的速度慢一点的时候，即软引用在GC时来得及回收，那么内存会一直有新的空间可以使用，OOM 的情况能得到缓解
        TimeUnit.SECONDS.sleep(1);
    }
}

Object obj = new Object();
ReferenceQueue queue = new ReferenceQueue();
WeakReference reference = new WeakReference(obj, queue);
//强引用对象滞空，保留软引用
obj = null;

/**
 * 虚引用测试
 * 测试时，注意设置JVM参数：-Xms128m -Xmx128m -XX:+PrintGCDetails
 *
 * 虚引用比软引用更脆弱，只要有GC时，虚引用就会被回收
 *
 * @throws Exception
 */
public static void testWeakReferences() throws Exception {
    List<WeakReference<MyReference>> list = new ArrayList<>();

    int index = 1;

    while (true) {
        int currentIndex = index++;
        list.add(new WeakReference<>(new MyReference(currentIndex)));
        System.out.println("the index = " + index + " MyReference inserted to list");
        TimeUnit.MILLISECONDS.sleep(500);
    }
}

Object obj = new Object();
ReferenceQueue queue = new ReferenceQueue();
PhantomReference reference = new PhantomReference(obj, queue);
//强引用对象滞空，保留软引用
obj = null;

/**
 * 幻影引用
 * 测试时，注意设置JVM参数：-Xms128m -Xmx128m -XX:+PrintGCDetails
 *
 * 幻影引用必须配合 ReferenceQueue 使用，
 * 因为使用 PhantomReference 对象本身是拿不到该具体实例，当这个幻影引用被回收时，就会放到 ReferenceQueue 队列中
 *
 * 最佳实践：
 * @See org.apache.commons.io.FileCleaningTracker
 *      org.apache.commons.io.FileCleaningTracker.Tracker
 */
private static void testPhantomReferences() throws Exception {
    int index = 10;
    MyReference reference = new MyReference(index);
    ReferenceQueue referenceQueue = new ReferenceQueue<>();
    MyPhantomReference phantomReferences = new MyPhantomReference(reference, referenceQueue, index);

    reference = null;
    System.gc();
    
    // 等待真正GC一下， 保证虚引用被回收
    TimeUnit.SECONDS.sleep(2);
    // phantomReferences.get() 拿不到对象
    System.out.println(phantomReferences.get());
    // 虚引用被回收会进入 ReferenceQueue 队列中
    Reference object = referenceQueue.remove();
    ((MyPhantomReference)object).doAction();
}

private static class MyPhantomReference extends PhantomReference<Object> {

    private final int index;

    public MyPhantomReference(Object referent, ReferenceQueue<? super Object> queue, int index) {
        super(referent, queue);
        this.index = index;
    }

    public void doAction() {
        System.out.println("index = [ "+ index +"] will be GC");
    }
}

public interface LruCache<K, V> {

    /**
     * 插入数据
     * 当容器满的时候，将最久访问的数据从容器中移除，
     * 并将新加入的数据放入容器中
     * @param key
     * @param value
     */
    void put(K key, V value);

    /**
     * 获取数据
     * @param key
     * @return
     */
    V get(K key);

    /**
     * 将指定元素从容器中移除
     * @param key
     */
    void remove(K key);

    /**
     * 清空缓存
     */
    void clear();

    /**
     * 缓存当前已存有效数据的容量大小
     * @return
     */
    int size();

    /**
     * 当前缓存容器的最大可缓存容量
     * @return
     */
    int limit();
}