基于Kryo的深拷贝

import com.esotericsoftware.kryo.Kryo;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.Collectors;

public class CopyUtils {

    private static final ThreadLocal<Kryo> KRYO_THREAD_LOCAL = ThreadLocal.withInitial(
            () -> {
                Kryo kryo = new Kryo();
                kryo.setRegistrationRequired(false);
                return kryo;
            });

    private static final ForkJoinPool COPY_THREAD_POOL = new ForkJoinPool(10);

    /**
     * 基于kryo的深拷贝
     * @param target
     * @param <T>
     * @return
     */
    public static <T> T deepCopyByKryo(T target) {
        Callable<T> copyTask = () -> {
            Kryo kryoInstance = KRYO_THREAD_LOCAL.get();
            return kryoInstance.copy(target);
        };
        T copy;
        try {
            copy = COPY_THREAD_POOL.submit(copyTask).get();
        } catch (ExecutionException | InterruptedException e) {
            throw RuntimeException(e);
        }
        return copy;
    }

    /**
     * 基于kryo的List深拷贝
     * @param targetList
     * @param <T>
     * @return
     */
    public static <T> List<T> deepCopyByKryo(List<T> targetList) {
        Callable<List<T>> copyTask = () -> targetList
                .parallelStream()
                .map(target -> {
                    Kryo kryoInstance = KRYO_THREAD_LOCAL.get();
                    return kryoInstance.copy(target);
                })
                .collect(Collectors.toList());
        List<T> copyList;
        try {
            copyList = COPY_THREAD_POOL.submit(copyTask).get();
        } catch (ExecutionException | InterruptedException e) {
            throw RuntimeException(e);
        }
        return copyList;
    }

}