Java method - levels of abstraction

Your exception handling for new ServerSocket(port) could be better. I don't like the way System.exit(1) is buried in a helper function. The exception should be caught in such a way that it bypasses the clientSocket-accepting loop.

Similarly, if serverSocket.accept() throws an exception, you log it, but blithely proceed to try to create a client thread anyway. Instead, the client-thread-creating code should be inside the try block, so that the exception would cause it to be skipped.

Here is a preliminary rearrangement to fix the exception handling.

public void run() {    
    try {
            serverSocket = new ServerSocket(port);

            isRunning = true;
            while (isRunning) {
                    try {
                            Socket clientSocket = serverSocket.accept();
                            Client client = new Client(clientSocket, this);
                            connectedClients.put(client.getID(), client);
                            Thread clientThread = new Thread(client);
                            clientThread.start();
                            logEvent("Accepted new connection from " + clientSocket.getRemoteSocketAddress().toString());
                            // The "hello" should be sent by the clientThread code instead
                            // client.send("@SERVER:HELLO");
                    } catch (IOException e) {
                            logEvent("Could not accept incoming connection.");
                    }
            }
    } catch (IOException | IllegalArgumentException e) {
            System.out.println("Could not bind socket to given port number.");
            System.out.println(e);
            System.exit(1);
    }
}

If you would like to offload some responsibility from this method, you could create "client tasks" to be put into a "client processing pool". Then this run() method could be wonderfully generic.

As noted above, client.send("@SERVER:HELLO") belongs in the clientThread code, not in this loop.

I don't like either solution (or the currently suggested answers). In any application where you run a ServerSocket, I believe that the socket management should be done on the Main thread. This would avoid the exact situation where you have a System.exit(1). The basic pattern for a server application is:

public static void main(String[] args) {
    // sort out the arguments, if any.
    int port = 12345; // default, args can override

    // open the ServerSocket to ensure you can reserve the port befor you do expensive setup.
    try (ServerSocket serverSocket = createServerSocket(port)) {
        // Initialize the system
        setup();

        listenForClients(serverSocket);

    } catch (IOException ioe) {
        // deal with exception
        // can do System.exit(1) in the main thread to set exit codes...
        // but my personal preference is to throw an exception from the main method.
        // whihc exits with 1, and still does a clean shutdown.
    }  
}

There are some things you are doing wrong with your ClientThread setup. If you want the client threads to die when the main thread stops then you should set them to be Daemon threads:

Thread clientThread = new Thread(client);
clientThread.setDaemon(true);

The Java system will terminate when all non-Daemon threads stop. If your only non-Daemon thread is the Main thread (it is always non-Daemon), then the system will exit cleanly when the main thread ends.

You can use this to your advantage in a number of ways... including having a terminating variable like AtomicBoolean isRunning = new AtomicBoolean(true) which any thread can set to false, and the main thread will periodically check... (using a Selector and a ServerSocketChannel - an advanced concept)

The bottom line is that you are not setting Daemon threads appropriately, and as a consequence, you need heavy-weight System.exit(1). Your ServerSocket management should be on the main thread too (or, it is possible, to make it on the only non-Daemon thread by spawning it from the Main thread, and letting the main thread exit normally).