java - 从 SynchronizedMultimap 中删除元素会增加意外行为

Question

我正在使用 Guava 18.0 的同步 SetMultimap

该集合声明如下

private SetMultimap<String, Foo> fooMultimap;

private StatusService() {
    this.fooMultimap = Multimaps.synchronizedSetMultimap(HashMultimap.<String, Foo>create());
}

其中 StatusService 是 spring boot @Service ，它当然被视为单例。 SetMultimap 是一个多重映射，包含其中 Foo 是一个具有多个属性的模型。

因此我有以下方法:

/* remove element */
public void removeFoo(String fooId, Foo foo) {
    fooMultimap.remove(fooId, foo);
}

还有

/* remove element by unique property(element path) */
public void removeByPath(String path) {
    Lists.newArrayList(getAllFoos().values()).stream()
                .filter(Objects::nonNull)
                .filter(foo -> Optional.ofNullable(foo.getPath())
                        .filter(fooPath -> fooPath.contains(path))
                        .isPresent()
                ).forEach(filteredFoo -> removeFoo(img.getId(), img));
  }
}

和getAllFoos()方法如下

public SetMultimap<String, Foo> getAllFoos() {
    return this.fooMultimap;
}

我不明白的是为什么 Guava 不从多重映射中删除元素，也许我做错了什么，我已经尝试了所有可能的组合，如 .values() 或 .asMap() 或 .entries() 没有任何运气。

有人可以解释一下从 Guava synchronized SetMultimap 中删除键、值条目的最佳方法是什么吗？

<小时/>

这是重现我的问题的示例，如果我更改对象，则我无法再删除条目。当我更改图像的状态时会发生更改

package test;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;

import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

public class Test {


    public static SetMultimap<String, Image> mm;

    public static void main(String args[]) {
        mm = Multimaps.synchronizedSetMultimap(HashMultimap.<String, Image>create());
        Image i1 = new Image("1", ImageState.DONE, "original", "path1");
        Image i2 = new Image("2", ImageState.DONE, "original", "path1");
        Image i3 = new Image("3", ImageState.DONE, "original", "path1");
        Image i4 = new Image("2", ImageState.DONE, "original", "path2");
        Image i5 = new Image("2", ImageState.DONE, "original", "path2");

        mm.put("1", i1);
        mm.put(i2.getId(), i2);
        mm.put("3", i3);
        mm.put("2", i4);
        mm.put(i5.getId(), i5);

        System.out.println("original multimap:" + mm.toString());

        // when altering an object everything goes down the drain and 
        // objects are not removed correctly as expected.
        getImageByMetadata(i2).setStatus(ImageState.PENDING);

        Image i6 = getImageByMetadata(i2);

        System.out.println(i2);
        System.out.println(i6);

        mm.remove(i6.getId(), i6);
        System.out.println("multimap should be smaller 1:" + mm.toString());

        mm.get(i6.getId()).remove(i6);
        System.out.println("multimap should be smaller 2:" + mm.toString());

        mm.asMap().get(i2.getId()).remove(i2);
        System.out.println("multimap should be smaller 3:" + mm.toString());

        removeByPath("path2");
        removeByPath("path1");
        System.out.println("should remove 2 elements:" + mm.toString());

    }

    public static Image getImageByMetadata(Image imageMetadata) {
        List<Image> images = Lists.newArrayList(mm.values());
        List<Image> filteredImage = mm.values().stream()
                .filter(Objects::nonNull)
                .filter(image -> imageMetadata.getId().equals(image.getId()) &&
                        imageMetadata.getFormat().equals(image.getFormat()) &&
                        Optional.ofNullable(image.getPath())
                                .filter(thisPath -> thisPath.contains(imageMetadata.getPath()))
                                .isPresent()
                ).collect(Collectors.toList());

        if (filteredImage.size() == 0) {
            return new Image();
        } else {
            return filteredImage.get(0);
        }
    }

    public static void removeByPath(String path) {
        mm.get("2").stream()
                .filter(Objects::nonNull)
                .filter(image -> Optional.ofNullable(image.getPath())
                        .filter(imagePath -> imagePath.contains(path) && image.getStatus().equals(ImageState.DONE))
                        .isPresent()
                ).forEach(img -> {
            mm.values().remove(img);
        });
    }
}

class Image {

    private String id;
    private ImageState status;
    private String format;
    private String path;

    public Image() {
    }

    public Image(String id, ImageState status, String format, String path) {
        this.id = id;
        this.status = status;
        this.format = format;
        this.path = path;
    }

    public ImageState getStatus() {
        return status;
    }

    public Image setStatus(ImageState status) {
        this.status = status;
        return this;
    }

    public String getPath() {
        return path;
    }

    public Image setPath(String path) {
        this.path = path;
        return this;
    }

    public String getId() {
        return id;
    }

    public void setId(String thatId) {
        id = thatId;
    }

    public String getFormat() {
        return format;
    }

    public void setFormat(String thatFormat) {
        format = thatFormat;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Image)) return false;
        Image image = (Image) o;
        return com.google.common.base.Objects.equal(id, image.id) &&
                status == image.status &&
                com.google.common.base.Objects.equal(format, image.format) &&
                com.google.common.base.Objects.equal(path, image.path);
    }

    @Override
    public int hashCode() {
        return com.google.common.base.Objects.hashCode(id, status, format, path);
    }

    @Override
    public String toString() {
        return "Image{" +
                "id='" + id + '\'' +
                ", status=" + status +
                ", format='" + format + '\'' +
                ", path='" + path + '\'' +
                '}';
    }
}

enum ImageState {
    DONE, PENDING, ABORTED, NOT_FOUND
}

Answer 1

自 Multimap<K,V>是一种Map<K,Set<V>> (尽管没有实现它)，它具有类似的语义，即插入后不得以影响其哈希码/相等性的方式修改元素。

除此之外，您还遇到了迭代然后查找反模式。这不仅效率低下，还可能导致ConcurrentModificationException与不支持对其迭代的集合进行修改的迭代器一起使用时(除了通过迭代器本身进行的修改之外)。

在大多数情况下，有简单的替代方案，例如而不是

public static void removeByPath(String path) {
    mm.get("2").stream()
            .filter(Objects::nonNull)
            .filter(image -> Optional.ofNullable(image.getPath())
                    .filter(imagePath -> imagePath.contains(path)
                                      && image.getStatus().equals(ImageState.DONE))
                    .isPresent()
            ).forEach(img -> {
        mm.values().remove(img);
    });
}

您可以简单地使用

public static void removeByPath(String path) {
    mm.get("2").removeIf(
        image -> Optional.ofNullable(image).map(Image::getPath)
                .filter(imagePath -> imagePath.contains(path)
                                  && image.getStatus().equals(ImageState.DONE))
                .isPresent()
        );
}

这避免了过时的查找并且不会抛出 ConcurrentModificationException s。请注意，虽然现在这可以工作，但即使哈希代码已更改，插入后更改哈希代码仍然不是正确的用法，并且后续查找可能失败的事实应该引起您的警惕。