从成员列表中删除时，创建新对象（扩展线程）会导致 UnsupportedOperationException<E>

Question

I have a MyObject() extends Thread which creates a new MyObject of itself in the run() method. This object has a List<E> as a member, where I delete from under certain conditions.

I when creating the new Object I call start() afterwards to start it's run method. But as soon as I spawn the new Object, it throws an

Exception in thread "Thread-1" java.lang.UnsupportedOperationException
at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:73)
at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.remove(ImmutableCollections.java:80)
at mypackage.MyMainClass.MyObject.run(MyObject.java:87)  <- here I remove from my List

Example:

public class MyObject extends Thread {
    List<SomeType> list = new ArrayList<SomeType>();
    SomeType st;

    public MyObject(SomeType st) {
        this.st = st;
        // returns a List of SomeType
        list = st.getList();
    }

    @Override
    public void run() {
        while(!done) {
            SomeType toDelete;
            if (condition) {
                toDelete = st.getToDelete();
            }
            // Checks for null etc are done and not important
            for (SomeType sometype : list) {
                if (somecondition) {
                    // toDelete is always in that List
                    list.remove(toDelete)
                } 
            }

            if (lastcondition) {
                MyObject newObject = new MyObject(this.st);
                newObject.start();
            }
        }
    }
}

Why do I get this error? Since the List is a member of each instance of the Object, why is it immutable for the new Threads, but not for my initial object?

Answer 1

Even when you fix UnsupportedOperationException your code that removes elements from list will throw ConcurrentModificationException because you are modifying list without using iterator while traversing list using iterator

for (SomeType sometype : list) { // this creates iterator behind the scene
    if (somecondition) {
        // toDelete is always in that List
        list.remove(toDelete); // this modifies the list and makes iterator throw ConcurrentModificationException
    } 
}

Answer 2

Problem was pointed out by @Joachim Sauer:

SomeType.getList returns a List implementation that does not support structural modification (or maybe no modification at all). See this question for a similar problem (with add() , but the problem source and solution is very similar).

The used list got created with List.of() which is immutable.