Why does this implementation of a thread work without a run method?-CodePudding

I have received some code through a school project and I'm failing to understand the purpose of the use of threading in this scenario. The project requires use of a multi threading server to pass. I have the following thread implementation which of a new instance is created every time a new client connects.

The problem is that they are not using the run-method, in my understanding the thread exists when it finishes running the run-method. But even after the thread should have finished running it manages to send further the messages from the propertyStateListener. Why does this work and does this really count as a multi-threaded server?

Starts an instance of the ClientHandler every time a new client connects:

@Override
public void run() {
    while (true) {
        MessageProducer mp;
        try {
            Socket socket = serverSocket.accept();
            new ClientHandler(socket).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

The actual ClientHandler:

private class ClientHandler extends Thread implements PropertyChangeListener {
    private Socket socket;
    private ObjectInputStream ois;
    private ObjectOutputStream oos;
    private Message messagerecieved;

    public ClientHandler(Socket socket) throws IOException {
        this.socket = socket;
        oos = new ObjectOutputStream(socket.getOutputStream());
        ois = new ObjectInputStream(socket.getInputStream());
        messageManager.registerListener(this);
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        messagerecieved = (Message) evt.getNewValue();
        try {
            oos.writeObject(messagerecieved);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

    }
}

CodePudding user response：

The problem is that they are not using the run-method, in my understanding the thread [exits] when it finishes running the run-method. But even after the thread should have finished running it manages to send further the messages from the propertyStateListener.

You are correct that the code is confusing for sure. They are creating a thread with each instance of ClientHandler but there is no run() method so the thread immediately exits after start() is called. The code would actually still work if ClientHandler did not extend thread.

Why does this work

It is the messageManager thread which is calling back to the ClientHandler.propertyChange(...) method which writes the results back to the socket, not the ClientHandler thread.

does this really count as a multi-threaded server?

There certainly are 2 threads at work here because you have the socket-accept thread and the messageManager thread. Whether or not this is a "multi-threaded server" depends on the assignment I guess. Certainly if there was supposed to be a thread per client then this code does not do that.