Threads em Java

Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" Start.");
                System.out.println(Thread.currentThread().getName()+" End.");
            }
        }, delay, intervalo em milissegundos);

import java.net.Socket;
import java.net.ServerSocket;
import java.io.IOException;

class Main {
    public static void main(String[] args) {
        int porta = leEntrada(args);
        try {
            ServerSocket server = new ServerSocket(porta);
            while (true) {
                Socket client = server.accept();
                new Thread(codigoExecutadoPelaThread(client)).start();
            }
        } catch (IOException ex) {
            System.err.println("Ocorreu um erro na thread principal do servidor.");
            ex.printStackTrace();
        }
    }

    public static int leEntrada(String[] args) {
        int porta = -1;
        try {
            porta = Integer.parseInt(args[0]);
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException ex) {
            System.err.println("Chamda inválida. Uso: java Main <porta>");
            System.exit(1);
        }
        return porta;
    }

    public static Runnable codigoExecutadoPelaThread(Socket client) {
        return () -> {
            // aqui você coloca o código que vai ser executado numa nova thread,
            // que utiliza o client.
            // Eu acho melhor você criar uma classe que implementa a interface Runnable,
            // mas isso aqui vai servir.
            try {
                client.close();
            } catch (IOException ex) {
                System.err.println("Erro ao tentar fechar o socket.");
                ex.printStackTrace();
            }
        };
    }

}

private void iniciarServidor()

{

try {

serverSocket5 = new ServerSocket (2345);

serverSocket6 = new ServerSocket (2346);

serverSocket7 = new ServerSocket (2347);

serverSocket8 = new ServerSocket (2348);

jLabelServidor.setText(“Servidor Online”);

} catch (IOException ex) {

Logger.getLogger(Menu_Jf.class.getName()).log(Level.SEVERE, null, ex);

}

new Thread()
    {
    public void run()
    {
   
    try
        {    
        while(true)
        {
            Socket socket5 = serverSocket5.accept();
        if (socket5.isBound()== true)
        {
          JOptionPane.showMessageDialog(null,"Leitor 5. Conexão Iniciada com IP:  \n"+socket5.getInetAddress().toString()+"Porta: "+socket5.getPort());
          Recebido = new DataInputStream(socket5.getInputStream());
          if(Recebido.readUTF().equals("FIM"))
          {
          //JOptionPane.showMessageDialog(null,"Leitor 5 desconectou");
          Recebido = null;
          }
          }

Thread t = new Thread(runnable);
// essa chamada ao método start() retorna imediatamente,
// e a thread que estamos agora continua
// executando normalmente.
t.start();
outraOperacao();
outraOperacao();
//...

import java.net.Socket;
import java.net.ServerSocket;
import java.io.IOException;

class Main {

    public static void main(String[] args) {
        ThreadCustomizada t1 = new ThreadCustomizada(2345, "Cliente 1");
        ThreadCustomizada t2 = new ThreadCustomizada(2346, "Cliente 2");
        ThreadCustomizada t3 = new ThreadCustomizada(2347, "Cliente 3");
        ThreadCustomizada t4 = new ThreadCustomizada(2348, "Cliente 4");
        // até aqui tem apenas 1 thread rodando (na verdade tem outras, o Garbage Collector por exemplo, mas enfim)
        t1.start(); // a partir daqui existem 2 threads rodando
        t2.start(); // 3 agora
        t3.start(); // 4
        t4.start(); // 5 threads rodando

        // aqui a thread principal morre quando acaba o método main,
        // mas as outras 4 estão executando, por isso o programa continua até que todas morram
    }
}

class ThreadCustomizada extends Thread {
    private final int porta;
    private final String nomeDoCliente;
    /*
        pode passar o que quiser pro construtor,
        tudo o que for necessário para lidar com o cliente
    */
    ThreadCustomizada(int porta, String nomeDoCliente) {
        this.porta = porta;
        this.nomeDoCliente = nomeDoCliente;
    }
    @Override
    public void run() {
        try {
            ServerSocket server = new ServerSocket(this.porta);

            // Fica esperando o cliente se conectar sempre
            while (true) {
                // essa chamada bloqueia (fica travada, não sai do lugar)
                // até que o cliente se conecte. Quando isso acontecer,
                // o método accept retorna e a execução continua.
                Socket client = server.accept();
                // aqui você faz tudo o que quiser com o socket
                // no momento que o cliente sair, o while reinicia
                // e fica esperando por aquele cliente específico novamente,
                // na mesma porta
                client.close();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}