FATAL EXCEPTION: main Process PID: 20793 java.util.ConcurrentModificationException

The program is written for scanners / terminals that scan tags accordingly.
The method in which the error occurs:

public synchronized void generateBlocksWithAfterRFIDRead(Object obj) {
            if (searchRFID != null && !isSync) {
                HashSet<String> newmarks = (HashSet<String>) obj;
                if (newmarks.isEmpty()) return;
                int i = 0;
    
                Log.w("Тэг", "В новом наборе всего тегов : " + newmarks.size());
                int w = 0;
                for (String mark : newmarks) {
                    Log.w("Тэг", "В новом наборе тэг номер " + i++ + " : " + mark);
                    if (!(marks == null)) {
                        if (marks.contains(mark)) {
                            Log.w("Tag", "Уже содержит такой тэг! Сам тэг : " + mark);
                            continue;
                        }
                    } else {
                        marks = new HashSet<>();
                    }
                    marks.add(mark);

The line for (String mark: newmarks) {

As I understand it, an error occurs when changing a collection, but such an error is triggered if you scan a "Large" number of tags at once, with a single scan - such errors do not occur.
How can this error be corrected? How can a set be modified correctly?

** UPD: ** method that uses the method described above

public HandlerRFID(RFIDReader reader, SearchResultsActivity activity) {
            timeMillis1 = System.currentTimeMillis();
            myReader = RFIDReaderSingleton.reader;
            acitivityUISearchRes = activity;
            readedMarks = new HashSet<>();
    
    
            handler = new Handler(Looper.getMainLooper()) {
                @Override
                public void handleMessage(Message msg) {
                    // Gets the image task from the incoming Message object.
                    // running on mainUi
                    if (msg.what == StatusesMainUIUpdate.ALL_MARKS_ARE_READED) {
                        acitivityUISearchRes.generateBlocksWithAfterRFIDRead(msg.obj);
                        readedMarks = null;
                    } else {
                        super.handleMessage(msg);
                    }
                }
            };
        }

Stacktrace:

/com.example.testingodata E/AndroidRuntime: FATAL EXCEPTION: main
        Process: com.example.testingodata, PID: 20793
        java.util.ConcurrentModificationException
            at java.util.HashMap$HashIterator.nextEntry(HashMap.java:851)
            at java.util.HashMap$KeyIterator.next(HashMap.java:885)
            at com.example.testingodata.View.SearchResultsActivity.generateBlocksWithAfterRFIDRead(SearchResultsActivity.java:401)
            at com.example.testingodata.HandlerRFID$6.handleMessage(HandlerRFID.java:184)
            at android.os.Handler.dispatchMessage(Handler.java:102)
            at android.os.Looper.loop(Looper.java:154)
            at android.app.ActivityThread.main(ActivityThread.java:6123)
            at java.lang.reflect.Method.invoke(Native Method)
            at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:889)
            at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:779)

From the HashSet docs:

> The iterators returned by this class's iterator method are fail-fast: if the set is modified at any time after the iterator is created, in any way except through the iterator's own remove method, the Iterator throws a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Basically, when you're iterating over a collection, you shouldn't modify that same collection - you'll see this same warning under HashMap, LinkedList etc. It causes unpredictable behaviour, and there are different changes you could make that would affect the current state in different ways, so they just make it fail and say "so don't do that!"

As for why it happens with large batches and not a single scan:
> Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis.

So it's probably just more likely that a large set of changes will get noticed. It goes on to say "don't rely on this behaviour" so you should probably do things in a different way! Usually you would just create a separate Set (an empty one, or a copy of your original) and make changes to that, and then return it or swap the original out for it when you're done.

Just to be clear, the problem here is that you're creating an iterator on a collection (with the for loop) and then modifying that collection while the iterator is running on it. I noticed you have synchronized on your method, so if you're also accessing the same collection on different threads, you have to make sure you're doing that in a thread-safe way too - the HashSet link talks a bit about that stuff