ntão, eu tenho dois thread

Thread one gerencia as conexões do cliente. (Existe apenas um cliente e um servidor)
Eu chamo de meu thread do servidor.

Thread two gerencia o envio de mensagens para o cliente. Eu chamo isso de meu thread do processador de mensagen

A pessoa responsável é responsável, entre outras coisas, enviando um batimento cardíaco para o cliente periodicament

Na programação, assumi que os soquetes não eram seguros para threads, mas os buffers eram, e enquanto eu estivesse usando buffers separados para os threads do servidor e do processador, eu ficaria be

Também assumi que o "PrintWriter" era análogo ao buffer de soquete em Jav

Sob essas suposições, escrevi esta função para enviar um batimento cardíaco:

public void sendHeartBeat(){
        logger.info("Sending a hearbeat!");
        PrintWriter printWriter=null;
        try {
            printWriter = new PrintWriter(clientSocket.getOutputStream());
        } catch (IOException e) {
            logger.info(e.toString());
        }
        if(printWriter!=null){
            printWriter.print("HEARTBEAT#");
            printWriter.flush();
        }
    }

O outro segmento, o "processador" faz algo semelhante no que faz:

printWriter=new PrintWriter(theServer.getClientSocket().getOutputStream());

Dessa maneira, eu criaria um novo "buffer" toda vez que desejasse enviar um batimento cardíaco e minhas mensagens nunca seriam substituída

Infelizmente, este não parece ser o caso. E recebo uma mensagem que chega pelo canal assim: dsgdsbHEARTBEAT # sdg

Isso causa um dump principal mais tard

Aqui estão minhas perguntas:

1) Os soquetes obviamente não são seguros para threads, mas os PrintWriters que recebo deles são seguros para threads? Ou está apenas retornando o mesmo PrintWriter?

2) O que é análogo ao buffer de soquete em Java? Como devo pensar sobre esse problema?

3) Como faço para que esses threads não gravem no mesmo buffer no soquet