Java中如何安全传递泛型对象副本至异步方法且保持原对象完整

希望在Java中针对泛型参数安全实现如下逻辑，保证原参数param不受异步线程修改的影响：

public <I, O> O method(final I param){

    I copy1 = //创建param的第一个副本;
    I copy2 = //创建param的另一个副本;

    asyncMutatingThread1(copy1); //处理时修改copy1并保存至db-01
    asyncMutatingThread2(copy2); //处理时修改copy2并保存至db-02

    //主线程中继续使用param ...
    return process(param); //返回<O>类型结果
}

限制条件：

• 无法控制或预知传入param的具体类型，自定义拷贝逻辑不可行。
• 尝试过Jackson深拷贝，但嵌套类未注册自定义反序列化器时无法正常工作，且无法预知所有嵌套类型。

1. 基于Java序列化的通用深拷贝 #

利用Java对象序列化机制实现深拷贝，只要目标对象及其所有嵌套对象都实现Serializable接口，就能自动处理嵌套结构，无需手动注册类型。

实现代码 #

import java.io.*;

public class DeepCopyUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepCopy(T obj) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(obj);
        oos.close();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        T copy = (T) ois.readObject();
        ois.close();
        return copy;
    }
}

使用方式 #

在目标方法中调用：

I copy1 = DeepCopyUtils.deepCopy(param);
I copy2 = DeepCopyUtils.deepCopy(param);

注意点 #

• 带transient修饰的字段不会被拷贝，会保留默认值。
• 部分JDK内置类型（如Thread、InputStream）不支持序列化，这类对象无法用此方法拷贝。

2. 利用第三方工具类简化序列化拷贝 #

直接使用成熟第三方库封装的序列化拷贝工具，避免重复造轮子，比如Apache Commons Lang的SerializationUtils.clone()方法：

依赖（Maven） #

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

使用方式 #

import org.apache.commons.lang3.SerializationUtils;

//...
I copy1 = SerializationUtils.clone(param);
I copy2 = SerializationUtils.clone(param);

3. 基于反射实现通用深拷贝（无序列化依赖） #

如果无法依赖Serializable接口，可通过反射遍历对象所有字段，递归实现深拷贝，灵活性更高，但需处理更多边缘情况：

实现代码示例 #

import java.lang.reflect.Field;
import java.util.*;
import java.lang.reflect.Array;

public class ReflectDeepCopyUtils {
    private static final Map<Object, Object> copiedObjects = new HashMap<>();

    @SuppressWarnings("unchecked")
    public static <T> T deepCopy(T obj) throws IllegalAccessException, InstantiationException {
        if (obj == null) {
            return null;
        }
        // 处理循环引用
        if (copiedObjects.containsKey(obj)) {
            return (T) copiedObjects.get(obj);
        }
        Class<?> clazz = obj.getClass();
        // 处理基本类型、包装类、String、枚举
        if (clazz.isPrimitive() || clazz == String.class || clazz.isEnum()) {
            return obj;
        }
        // 处理数组
        if (clazz.isArray()) {
            Class<?> componentType = clazz.getComponentType();
            int length = Array.getLength(obj);
            Object newArray = Array.newInstance(componentType, length);
            copiedObjects.put(obj, newArray);
            for (int i = 0; i < length; i++) {
                Array.set(newArray, i, deepCopy(Array.get(obj, i)));
            }
            return (T) newArray;
        }
        // 处理集合
        if (Collection.class.isAssignableFrom(clazz)) {
            Collection<T> newCollection = (Collection<T>) clazz.newInstance();
            copiedObjects.put(obj, newCollection);
            for (T item : (Collection<T>) obj) {
                newCollection.add(deepCopy(item));
            }
            return (T) newCollection;
        }
        // 处理Map
        if (Map.class.isAssignableFrom(clazz)) {
            Map<Object, Object> newMap = (Map<Object, Object>) clazz.newInstance();
            copiedObjects.put(obj, newMap);
            for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) obj).entrySet()) {
                newMap.put(deepCopy(entry.getKey()), deepCopy(entry.getValue()));
            }
            return (T) newMap;
        }
        // 处理普通对象
        T newObj = (T) clazz.newInstance();
        copiedObjects.put(obj, newObj);
        // 遍历当前类及父类的所有字段
        while (clazz != null) {
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                Object fieldValue = field.get(obj);
                field.set(newObj, deepCopy(fieldValue));
            }
            clazz = clazz.getSuperclass();
        }
        copiedObjects.remove(obj);
        return newObj;
    }
}

使用方式 #

I copy1 = ReflectDeepCopyUtils.deepCopy(param);
I copy2 = ReflectDeepCopyUtils.deepCopy(param);

注意点 #

• 反射拷贝性能低于序列化拷贝，适合对性能要求不高的场景。
• 目标类需要有无参构造函数，否则会抛出InstantiationException。
• 不可变类（如LocalDateTime）可直接返回原对象，无需拷贝。

4. 约束输入类型（备选方案） #

如果上述方案均不适用，可在方法签名中添加类型限定，强制输入类型支持拷贝：

public <I extends Serializable, O> O method(final I param)

若选择Cloneable接口，需注意默认clone()是浅拷贝，需目标类重写方法实现深拷贝，实用性较低。

内容的提问来源于stack exchange，提问作者SourceVisor