在迭代器内部的线程内删除Collection的元素

Question

i have this loop:

for (Iterator<Socket> it = collection.iterator(); it.hasNext();) {
    Object obj = it.next();
    new Thread( () -> {
        if(myCondition(obj)){
            it.remove();
        }
    }).start();
}

Sometimes it works, but sometimes i get a java.lang.IllegalStateException when calling it.remove(); Is there a safe way to do this?

---UPDATE---

I need to do this in a code running on a Server, that receives connections from a lot of client Sockets. This code performs some queries from time to time, and for each time a query is performed, the result is sent to all the connected sockets. So, for each socket, i create a new Thread to do this. What i am trying to remove from the list are the closed sockets.

This is a sample of how my server works:

public class SocketServidor {
    static ServerSocket serverSocket;
    static List<Socket> socketsConectados = new ArrayList<>();

    public static void main(String[] args) throws Exception {
        serverSocket = new ServerSocket(5963);

        new Thread( ()-> {
            lacoConexao:
            while(true) {
                try {
                    socketsConectados.add(serverSocket.accept());
                } catch (IOException ex) {
                    Logger.getLogger(SocketServidor.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }).start();

        lacoMensagens:
        while(true) {
            int valor = (int) (Math.random() * 3) + 1;
            lacoIterators:
            for (Iterator<Socket> it = socketsConectados.iterator(); it.hasNext();) {
                Socket socket = it.next();
                new Thread( () -> {
                    try {
                        if(socket.isClosed()) {
                            return;
                        }
                        PrintWriter out = new PrintWriter(socket.getOutputStream());
                        out.println("Você acabou de ganhar R$ "+new DecimalFormat("###,##0.00").format(valor)+" às "+new SimpleDateFormat("HH:mm:ss").format(new Date())+"!");
                        if(out.checkError()){
                            socket.close();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            System.out.println("Sockets conectados: "+socketsConectados.size());
            Thread.sleep(valor*1000);
        }
    }
}

Answer 1

You should read more about thread safety. I can tell you what to fix in your code but until you understand concurrency properly you will keep adding bugs every time you write a line of code...

You should:

• use a thread safe list, for example a List<Socket> socketsConectados = new CopyOnWriteArrayList<>();
• use a thread pool instead of creating one thread per socket: ExecutorService executor = Executors.newCachedThreadPool();
• submit the task of sending messages to the thread pool instead of creating threads manually
• also those labels you are using are confusing, they are supposed to be used to break from an outer loop - if all you want is to comment your code, use comments!

---

For reference the code could look like this:

public class SocketServidor {
  static ServerSocket serverSocket;
  private static final ExecutorService executor = Executors.newCachedThreadPool();
  private static final List<Socket> sockets = new CopyOnWriteArrayList<>();

  public static void main(String[] args) throws Exception {
    serverSocket = new ServerSocket(5963);
    new Thread(SocketServidor::acceptSockets).start();
    sendMessages();
  }

  private static void acceptSockets() {
    while (true) {
      try {
        sockets.add(serverSocket.accept());
      } catch (IOException ex) {
        Logger.getLogger(SocketServidor.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
  }

  private static void sendMessages() throws InterruptedException {
    while (true) {
      int valor = (int) (Math.random() * 3) + 1;
      for (Socket socket : sockets) {
        executor.submit(() -> {
          if (socket.isClosed()) sockets.remove(socket);
          else sendMessage(socket, valor);
        });
      }
      System.out.println("Sockets conectados: " + sockets.size());
      Thread.sleep(valor * 1000);
    }
  }

  private static void sendMessage(Socket socket, int valor) {
    try {
      PrintWriter out = new PrintWriter(socket.getOutputStream());
      out.println("Você acabou de ganhar R$ " + new DecimalFormat("###,##0.00").format(valor) + " às " + new SimpleDateFormat("HH:mm:ss").format(
              new Date()) + "!");
      if (out.checkError()) {
        socket.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Answer 2

Your code is not thread-safe. It has both visibility issues and concurrency issues.

You start your iteration and pass an object and your iterator reference to another thread, and you continue your iteration in your main thread. Before it.remove() executes on the second thread, your main thread has already completed the iteration. Even if it does not complete the iteration, your "check-then-act" action is not atomic. There is no guarantee that your "it" reference still points the "obj" reference you decided to remove.

Additionally, your "it" reference is not passed to the other thread in a thread-safe manner, therefore you have a visibility issue. Changes in your iterator object is not guaranteed to be visible to the other threads.

There is no point of removing objects from the list from multiple threads with your current approach. Because your iterate sequentially on the whole list. When you decide to remove an object using the iterator, you have to make sure that you haven't iterated to the next object using a lock or synchronized block, which makes multi-threading useless.

You should use a concurrent data structure such as ConcurrentHashMap, or provide proper synchronizations in your threads.

List interface, and any concurrent or non-concurrent implementation of List interface is not suitable for this use case. Using a list for a random set of client sockets does not make sense unless the order of connecting to server is important. CopyOnWriteArrayList is not efficient if number of updates is big. Removing an item from the list with O(n) is also not efficient if number of clients is big. Clients probably connect and disconnect randomly, without no-ordering guarantee etc. It is better to use a ConcurrentHashMap.