如何在 java 中同时添加和删除 collections 中的元素？

Question

I am trying to add elements and remove the elements in the list simultaneously. How to fix this problem?

public class Main3 {
    public static void main(String[] args) throws InterruptedException {
        Vector<Integer> list = new Vector<>();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                list.add(i);
                System.out.println("add " + i);
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("removed " + i);
                list.remove(i);
            }
        });
        t2.start();
    }
}
    

I get the following output:

**Error**

add 0
add 1
add 2
add 3
add 4
add 5
add 6
add 7
removed 0
add 8
add 9
removed 1
removed 2
removed 3
removed 4
removed 5
Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 5
    at java.base/java.util.Vector.remove(Vector.java:875)
    at com.zoho.Main3.lambda$1(Main3.java:23)
    at java.base/java.lang.Thread.run(Thread.java:829)

Answer 1

The first problem:

As you see from the comments, by using a for loop on your remove section, you are trying to remove a non-existing item.

What is going on?

Let's talk sheep.

You have 10 sheep, and each has a number 0 - 9. Your task is to remove all the sheep.

Since you are a Software developer and are afraid you might lose track, you decide to keep an index. You put your index on 0 and start removing sheep; after you remove a sheep, you make the index 1 more until you reach number 9.

You start by removing First sheep (Number 0). Here, however, is the catch, every time you remove a sheep, they all get assigned a new Number.

Sheep 0 is gone,
Sheep 1 becomes 0, 
Sheep 2 becomes 1... 

But the problem is that you don't update your index.

So all the rounds go well -> until you are trying to remove Sheep 5 . Sheep 5 does not exist. Since the highest Sheep Number is only 4.

Since there IS no sheep, you grab nothing and remove nothing and get confused:)

How to solve it?

You might be thinking; I will update my index after every round. NO NO NO! Bad practice:) Good for you for not doing that.

Let's just use some different logic instead of keeping an index. You do the following. Always remove the last sheep until there are non left. Why the last? If we remove the last, we don't even need to rename them after every round:) Super handy. In programming terms, let's use a while (list.size() > 0) instead of a for-loop/index.

Second problem

Since the two threads (workers) run at the same time. You may remove sheep faster than someone else can add them. Therefore, The remove worker can remove one sheep and then say: Wow, no sheep left, done for the day... As he leaves the farm, you add nine other sheep.

To solve this, we tell the Remove worker only to start when all the sheep has been added. We can do this by simply calling a join on the first thread. (Seee code below)

Now - you might think - what on earth is the advantage of using concurrency? Well, you can have multiple Remove workers and multiple Add workers: your CPU is literally the limit:)

The code as explained

public static void main(String[] args) throws InterruptedException {
    Vector<Integer> list = new Vector<>();
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            list.add(i);
            System.out.println("add " + i);
        }
    });
    t1.start();
    t1.join();

    Thread t2 = new Thread(() -> {
        while (list.size() > 0) {
            System.out.println("removed t2");
            list.remove(list.size() - 1);
        }
    });
    t2.start();
}

Final remark:

And here the fun begins... You will soon discover: Some sheep starving, workers waiting for each other forever, some workers holding on to sheep too long... Enjoy:)