线程“ Thread-0”中的异常java.util.NoSuchElementException？

Question

I am new to using threads. In another class an instance of the ConnectionMaster class is created and started (extends thread). A Client object is given to the ConnectionMaster object which adds it to the list. The overridden run() method of the Thread class essentially listens for a client to be added to the list. Indeed it does listen and "hears" when a Client object is added to the list. However, although .hasNext() returns true .Next() causes an exception. What am I doing wrong?

The following methods are from class ConnectionMaster which extends Thread:

Constructor

public ConnectionMaster(){
    clients = new Vector<>();
    listIterator = clients.listIterator();
}

Public method for adding client objects to the list

@Override
public synchronized void addClient(Client client) {
    listIterator.add(client);
}

This is the overridden thread method of the class Thread. It consistently checks for elements added to the list.

@Override
public void run(){
    while(true){
        while(listIterator.hasNext()){
            processClient(listIterator.next()); //this is where error occurs
            listIterator.remove();
        }

        while(listIterator.hasPrevious()){
            processClient(listIterator.previous());
            listIterator.remove();
        }
    }
}

////////////////////////////////UPDATE//////////////////////////////////// Thank You OldCurmudgeon and Stephen C. Based on your feedback, my code has been modified thus:

Constructor

public ConnectionMaster(){
    clients = new ArrayBlockingQueue<Client>(1024);
}

Method for receiving client objects

@Override
public synchronized void addClient(Client client) {
    try {
        clients.put(client);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Listener

@Override
public void run(){
    while(true){
        try {
            processClient((Client)clients.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Answer 1

This is a very strange way to implement Producer/Consumer. The usual way is to use a BlockingQueue .

public class TwoThreads {

    public static void main(String args[]) throws InterruptedException {
        System.out.println("TwoThreads:Test");
        new TwoThreads().test();
    }

    // The end of the list.
    private static final Integer End = -1;

    static class Producer implements Runnable {

        final BlockingQueue<Integer> queue;

        public Producer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i < 1000; i++) {
                    queue.add(i);
                    Thread.sleep(1);
                }
                // Finish the queue.
                queue.add(End);
            } catch (InterruptedException ex) {
                // Just exit.
            }
        }

    }

    static class Consumer implements Runnable {

        final BlockingQueue<Integer> queue;

        public Consumer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            boolean ended = false;
            while (!ended) {
                try {
                    Integer i = queue.take();
                    ended = i == End;
                    System.out.println(i);
                } catch (InterruptedException ex) {
                    ended = true;
                }
            }
        }

    }

    public void test() throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        Thread pt = new Thread(new Producer(queue));
        Thread ct = new Thread(new Consumer(queue));
        // Start it all going.
        pt.start();
        ct.start();
        // Wait for it to finish.
        pt.join();
        ct.join();
    }

}

Answer 2

What am I doing wrong?

Quite a lot actually.

First thing you are doing wrong is (apparently) using an ListIterator object in multiple threads. The ListIterator and Iterator implementations for Vector are not thread-safe ¹ , so what you are doing is potentially hazardous.

The second thing is that even if the iterators / list iterators were thread-safe, you are performing a sequence of operations (eg hasNext , next , remove ) without doing anything to ensure that the sequence of operations is performed in a way that is threadsafe. There is a distinct possibility that two threads could be performing the same sequence simultaneously on the shared iterator, and that one could interfere with the other.

I'm not sure what to suggest in order to fix your code. Two threads sharing an iterator is not going to work.

It would probably be better to ditch it, and use some kind of Queue as suggested by @OldCurmugeon.

---

Either problem 1 or problem 2 (as outlined above) could give rise to NoSuchElement exceptions.

---

^{1 - This is apparent from examining the source code - http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/java/util/Vector.java#Vector.ListItr .}