Поточно-безопасная сериализуемая коллекция с атомарной заменой

Самым простым решением будет внешняя синхронизация с ArrayList, возможно, через блокировку чтения-записи, например:

public class SyncList<T> implements Serializable {
    private static final long serialVersionUID = -6184959782243333803L;

    private List<T> list = new ArrayList<>();
    private transient Lock readLock, writeLock;

    public SyncList() {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readLock = readWriteLock.readLock();
        writeLock = readWriteLock.writeLock();
    }

    public void add(T element) {
        writeLock.lock();
        try {
            list.add(element);
        } finally {
            writeLock.unlock();
        }
    }

    public T get(int index) {
        readLock.lock();
        try {
            return list.get(index);
        } finally {
            readLock.unlock();
        }
    }

    public String dump() {
        readLock.lock();
        try {
            return list.toString();
        } finally {
            readLock.unlock();
        }
    }

    public boolean replace(T old, T newElement) {
        writeLock.lock();
        try {
            int pos = list.indexOf(old);
            if (pos < 0)
                return false;
            list.set(pos, newElement);
            return true;
        } finally {
            writeLock.unlock();
        }
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        readLock.lock();
        try {
            out.writeObject(list);
        } finally {
            readLock.unlock();
        }
    }

    @SuppressWarnings("unchecked")
    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        list = (List<T>) in.readObject();
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readLock = readWriteLock.readLock();
        writeLock = readWriteLock.writeLock();
    }
}

Предоставьте любые операции, которые вам нравятся, просто правильно используйте либо блокировку чтения, либо блокировку записи.

Моя неправильная первоначальная мысль заключалась в том, что CopyOnWriteArrayList была плохой идеей, поскольку она копирует все. Но, конечно, он выполняет только поверхностную копию, копируя только ссылки, а не глубокую копию, копируя также все объекты.

Поэтому мы явно выбрали CopyOnWriteArrayList, потому что он уже предлагал множество необходимых функций. Единственной оставшейся проблемой была replace, которая стала еще более сложной, чтобы быть addIfAbsentOrReplace.

Мы попробовали CopyOnWriteArraySet, но это не соответствовало нашим потребностям, потому что предлагало только addIfAbsent. Но в нашем случае у нас был экземпляр класса C с именем c1, который нам нужно было сохранить, а затем заменить обновленным новым экземпляром c2. Конечно, мы перезаписываем equals и hashCode. Теперь нам нужно было выбрать, хотим ли мы, чтобы равенство возвращало true или false для двух минимально разных объектов. Оба варианта не сработали, т.к.

• true будет означать, что объекты одинаковые, и набор даже не удосужится добавить новый объект c2, потому что c1 уже есть в наборе.
• false будет означать, что c2 будет добавлено, но c1 не будет удалено.

Поэтому CopyOnWriteArrayList. Этот список уже предлагает

public void replaceAll(UnaryOperator<E> operator) { ... }

что несколько соответствует нашим потребностям. Это позволяет нам заменить нужный объект с помощью пользовательского сравнения.

Мы использовали его следующим образом:

protected <T extends OurSpecialClass> void addIfAbsentOrReplace(T toAdd, List<T> elementList) {
    OurSpecialClassReplaceOperator<T> op = new OurSpecialClassReplaceOperator<>(toAdd);
    synchronized (elementList) {
        elementList.replaceAll(op);
        if (!op.isReplaced()) {
            elementList.add(toAdd);
        }
    }
}

private class OurSpecialClassReplaceOperator<T extends OurSpecialClass> implements UnaryOperator<T> {

    private boolean replaced = false;

    private T toAdd;

    public OurSpecialClassReplaceOperator(T toAdd) {
        this.toAdd = toAdd;
    }

    @Override
    public T apply(T toAdd) {
        if (this.toAdd.getID().equals(toAdd.getID())) {
            replaced = true;
            return this.toAdd;
        }

        return toAdd;
    }

    public boolean isReplaced() {
        return replaced;
    }
}