Problema: Executar 2 classes em paralelo com thread

import java.io.*;
import java.net.*;

/**
 *
 * @author Ricardo
 */
public class ServidorMultiplo implements Runnable {

    private static final int PORTA = 8123;
    private static final int MAX_CONEXOES = 20;
    //private Vector clientesConectados;
    private ServerSocket portaConexao;

    public ServidorMultiplo() {
       try {
          portaConexao = new ServerSocket(PORTA);
       } catch(IOException exc) {
          exc.printStackTrace();
       }
    }


    public void run() {
       Socket novaConexao = null;
       ConexaoCliente novoCliente = null;
       while(true) {
          try {
             novaConexao = portaConexao.accept();
             novoCliente = new ConexaoCliente(novaConexao);
             new Thread(novoCliente).start();

          } catch (IOException exc) {
             exc.printStackTrace();
          }
       }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       ServidorMultiplo novoServidor = new ServidorMultiplo();
                         

       new Thread(novoServidor).start();
    }

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

public class Anagrama {
    

    private static File arquivo;

    private static void leArquivo() {
        try {
            arquivo = new File("c:\catalogo.txt");
            arquivo.createNewFile();
            //le as linhas do arquivo
            FileInputStream fis = new FileInputStream(arquivo);
            BufferedReader br = leStream(fis);
            String s;
            String palavra;
            char vetor[];
            
            while ((s = br.readLine()) != null) {
                palavra = Retira_Espaco(s);

                vetor = new char[palavra.length()];


                /**
                 * metodo que armazena a palavra em vetor
                 */
                Quebra_Palavra(palavra, vetor);

                /**
                 * metodo que cria o anagrama
                 */
                Calcula_Anagrama(vetor, 0);
                Mostra(vetor);
                System.out.println(s);
            }

        } catch (IOException ex) {
            Logger.getLogger(Anagrama.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static BufferedReader leStream(FileInputStream fis) {
        InputStreamReader ir = new InputStreamReader(fis);
        BufferedReader in = new BufferedReader(ir);
        return in;
    }

    public static void main(String[] args) throws IOException {

        leArquivo();
        
         
        System.exit(0);
    }// fim main()
    
    private static void Mostra(char[] vetor) throws IOException {
        FileWriter writer = new FileWriter(new File("anagrama.txt"), true);
        PrintWriter saida = new PrintWriter(writer, true);
        saida.println(vetor);
      
        System.out.println("");
    }// fim metodo Mostra()
    /**
     * Este metodo recebe uma palavra e remove todos os espaços entre, durante e
     * no final de qualquer palavra.
     *
     * @param palavra
     * @return palavra_sem_espaços
     */
    private static String Retira_Espaco(String palavra) {
        String alterada = "", interna = (palavra).trim();
        char c;

        for (int i = 0; i < interna.length(); i++) {
            c = interna.charAt(i);
            if (Character.isLetterOrDigit(c)) {
                alterada += c;
            }// if
        }// for

        return alterada;
    }// fim metodo Retira_Espaco()
    /**
     * Este metodo recebe o vetor contendo a palavra e mostra para o usuario
     * todas as possibilidades de anagrama com esta palavra.
     *
     * @param vetor
     */
    private static void Calcula_Anagrama(char vetor[], int k) throws IOException {
        int i;
        if (k == vetor.length - 1) {
            Mostra(vetor);
        } else {
            Calcula_Anagrama(vetor, k + 1);
            i = k + 1;
            while (i < vetor.length) {
                Troca_Posicao(vetor, k, i);
                Calcula_Anagrama(vetor, k + 1);
                Troca_Posicao(vetor, k, i);
                i = i + 1;
            }
        }
    }// fim metodo Calcula_Anagrama()
    /**
     * Este metodo efetua a troca das posições desejadas
     *
     * @param vetor
     * @param i
     * @param k
     */
    private static void Troca_Posicao(char[] vetor, int k, int i) {
        char aux;
        aux = vetor[i];
        vetor[i] = vetor[k];
        vetor[k] = aux;
    }// fim metodo Troca_Posicao()
    /**
     * Este metodo recebe a palavra e um vetor vazio e retorna o vetor contendo
     * a palavra
     *
     * @param palavra
     * @param vetor
     */
    private static void Quebra_Palavra(String palavra, char vetor[]) {
        for (int i = 0; i < vetor.length; i++) {
            vetor[i] = palavra.charAt(i);
        }// for
    }// fim metodo Quebra_Palavra()

}