Limite do soquete Análise
O encaixe ou encaixe (socket) é uma peça de software na forma de um resumo, a expressão para a "final" de uma ligação entre duas máquinas. Para uma ligação particular, cada máquina tem um "socket", imagine há um "cabo" virtual entre eles. Há duas classes com base em Java fluxo de dados soquetes: ServerSocket, servidores usam para "ouvir" para conexões de entrada, tomada, uma vez que a conexão do cliente inicial com ele. Ouvir tomada só pode receber uma nova solicitação de conexão não podem ser recebidos do pacote real.
Tomada se baseia na aplicação TCP / IP, que é usado para fornecer acesso a uma interface de serviço TCP, ou um soquete TCP aplicação tomada de interface de programação API, por meio de que a camada de aplicativo pode acessar os serviços prestados pela TCP.
Em Java, criamos uma ServerSocket, classe Socket uma ligação de encaixe, os resultados obtidos a partir da tomada é um InputStream e OutputStream objectos a ser ligado como um mimo objeto de fluxo IO. Pode ser lido a partir do fluxo de dados fluxo de IO ou a gravação de dados para o fluxo, o fluxo vai escrever IO IOException exceção gerada.
Tomada underlayer é baseado em TCP, o limite do soquete TCP e tempos de espera são os mesmos. A seguir primeiro socket buffer write discussão, seguido por um tempo limite de conexão discussão estabelecimento, tempos de espera e tomada de gravação de programação Java captura exceção aninhada e captura de exemplo ilustrativo de um procedimento de tempo limite.
1 buffers de leitura e gravação de soquete
Depois de ter criado uma instância de tomada, o sistema operacional para receber e buffer a ser enviado será atribuído armazenar dados.
JAVA ler tamanho do buffer pode ser fornecida -setReceiveBufferSize (tamanho int), setSendBufferSize (int size).
não gravar dados para o fluxo de saída não significa que os dados tenham sido realmente enviado, mas eles são copiados para a transmissão tampão fila sendq, é chamar o método flush () no OutputStream soquete, não podemos garantir que os dados podem ser enviados para a rede imediatamente. Uma transmissão de dados real é tomada pelos dados módulo pilha de protocolo TCP sistema de operação transmitidos a partir do tampão com a rede de completo.
Quando os dados chegam a partir da rede, módulo pilha de protocolos TCP recebe os dados e colocado no buffer de fila RECVQ receber, recuperar dados a partir do fluxo de entrada InputStream RECVQ pelo método de leitura.
2 limite do soquete estabelecimento da conexão
conexão de soquete é estabelecida com base no processo de estabelecimento da conexão TCP. conexões TCP requerem pacotes através de um 3-way handshake para ser concluída, começou a estabelecer necessidades de sincronização para enviar um pacote SYN é uma conexão TCP, e depois espera por uma mensagem de confirmação SYN + ACK, e, finalmente, envia um ACK mensagem de confirmação. ligação TCP é fechada por quatro onda completa para um fim activa a ligação TCP transmite um pacote FIN, espera por um pacote de confirmação; passiva fechado um pacote FIN também é transmitido, e então espera que uma mensagem de reconhecimento.
Esperar TCP pedido de ligação fila ligada a uma extremidade de um comprimento fixo, ligado à fila de TCP foi aceite (isto é, handshake de três vias foi completada), mas não foi aceite pela camada de aplicação. Aceita uma ligação TCP é colocado na fila de ligação, a ligação da camada de aplicação é aceite que é removido da fila. A camada de aplicação para indicar que o comprimento máximo das variáveis fila de registro posterior ligação por definição, aceite por TCP número máximo de ligações já aguardando aceitação da camada de aplicação.
Quando uma solicitação de conexão chega SYN, TCP determina se a aceitar a conexão. Se não houver espaço na fila, o módulo TCP SYN irá confirmar e completar o estabelecimento da conexão. Mas só na camada de aplicação na terceira de três vias pacotes de handshake recebido você vai saber esta nova conexão. Se a fila estiver sem espaço, TCP irá ignorar o SYN recebido.
Se o servidor não consegue aceitar uma conexão TCP foi aceite, essas conexões podem ser preenchidos sua fila, o novo pedido de conexão fora de tempo pode não estar a responder. Se uma transmissão SYN pedido de ligação, nenhuma confirmação for recebida após um período de tempo SYN + ACK, TCP irá retransmitir o SYN pedido de ligação duas vezes, cada vez que duplicando o intervalo de retransmissão, ainda não recebida dentro de um período de tempo predeterminado SYN + ACK, TCP descarta a solicitação de conexão, a conexão é estabelecida em horas extras.
tempos de espera JAVA soquete e estabelecimento da conexão TCP são os mesmos, se os três-way handshake TCP para estabelecer um tempo limite de conexão, em seguida, ele leva ao estabelecimento da conexão socket expirou. Você pode definir o tempo limite de estabelecimento da conexão Socket -
connect (endpoint SocketAddress, tempo limite int)
Se dentro do tempo limite, a conexão não for estabelecida com sucesso, uma exceção é lançada em TimeoutException. Se o valor for menor que o de três vias tempo handshake tempo limite, então nunca será estabelecida a conexão Socket.
camadas de aplicação diferentes têm diferentes processos de estabelecimento de conexão, o estabelecimento da conexão de soquete e TCP o mesmo - só precisa de três vias aperto de mão para completar a ligação, mas algumas aplicações requerem o lote interação de informações com sucesso estabelecer uma conexão, como o protocolo Telnet, de três vias aperto de mão é concluída em TCP mais tarde, após a necessidade de negociação de opção, a conexão Telnet foi estabelecida.
3 Tomada ler tempo limite
Se a memória intermédia de entrada fila RECVQ sem dados, as operações de leitura teria sido bloqueada e thread suspenso até novos dados chegam ou uma excepção é gerada. Chamada setSoTimeout (int timeout) pode definir o tempo limite para tempo limite se não há dados ainda, leia irá lançar um SocketTimeoutException, procedimentos precisam pegar essa exceção, mas a conexão de soquete atual ainda é válido.
Se o outro processo falhar, o outro aparelho de repente reiniciado, desconectado da rede, o fim da leitura teria sido bloqueado para baixo, em seguida, definir os é muito importante, caso contrário, a chamada será sempre ler os trava rosca de tempo limite.
módulo TCP converte os dados recebidos em RECVQ até que a camada de aplicação solicita o fluxo de entrada para ler o método de leitura. Se a fila está cheia RECVQ, em seguida, notificar TCP mecanismo de deslizamento janela de acordo com o outro não continuar a dados de transmissão, o UE interrompe a extremidade receptora a partir dos dados transmitidos até que a aplicação de recipiente chama o método de leitura do fluxo de entrada desocupado espaço.
4 gravação tempo limite de soquete
Write tempo limite de soquete é baseado no tempo limite TCP retransmissão. Retransmissão tempo limite TCP é um mecanismo importante para garantir a segurança da transmissão de dados, o princípio é o de iniciar um temporizador após o envio de uma mensagem de dados, se não reconheceu pacotes ACK enviados em um determinado período de tempo, em seguida, re-enviar pacotes Wen. Se depois enviou-re várias vezes, ainda sem mensagem de confirmação, ele envia um pacote de reset RST, e depois fecha a conexão TCP. pacote de dados inicial e o tempo entre o envio de uma diferença de transmissão de mensagens de reposição de cerca de 9 minutos, ou seja, se o pacote não for confirmada dentro de 9 minutos, ele fecha a conexão. Mas este valor é baseado em uma implementação de pilha diferente do protocolo TCP e diferente.
Se os dados de gravação de chamadas remetente está continuamente escrita até que a fila está cheia sendq. Se você chamar o método de gravação na fila sendq está cheio, em seguida, escrever será bloqueado até que sendq até que haja um novo espaço livre, ou seja, até que o número de bytes transmitidos para o receptor na RECVQ socket. Se neste tempo de fila RECVQ foi preenchido, todas as operações são interrompidos até o fim de recepção de algum chama o método de leitura de transmitir bytes para a aplicação.
Quando a transmissão de dados escrever soquete se o cabo é desconectado, o fim remoto da máquina ou processo acidente de reinício, módulo TCP retransmite os dados e, finalmente, perto do tempo limite de conexão. Da próxima vez como gravação de chamadas, em seguida, irá causar uma exceção e sair.
mecanismo de retransmissão tempo de gravação tempo limite de soquete é baseado na pilha de protocolos TCP, geralmente não precisa set de gravação tempo limite, ele não forneceu tal método.
5 double exceção aninhada apanhado
Se a construção ServerSocket, soquete falhar, apenas não conseguiu captar a estrutura anormal, sem a necessidade de chamar o método close do soquete para liberar recursos (deve ser garantida a não deixar quaisquer recursos precisam ser apuradas após a construção falhar), porque então o soquete recursos internos palavra não são atribuídos com sucesso. Se a construção for bem sucedida, é necessário inserir uma tentativa finalmente instrução de chamada bloco de perto na liberação do soquete. Por favor, consulte os seguintes procedimentos de exemplo.
importar java.net. *; import java.io. *; classe pública SocketClientTest {int PORT public static final = 8088; public static void main (String [] args) throws Exception {InetAddress addr = InetAddress.getByName ( "127.0.0.1"); Socket = new Socket (); try {Socket.connect (novo InetSocketAddress (endereço, porta), 30000); socket.setSendBufferSize (100);
BufferedWriter out = new BufferedWriter( new OutputStreamWriter( socket.getOutputStream() ) );
int i = 0;
while( true )
{
System.out.println( "client sent --- hello *** " + i++ );
out.write( "client sent --- hello *** " + i );
out.flush();
Thread.sleep( 1000 );
}
}
finally
{
socket.close();
}
}
}
import java.io. *; importação java.net.ServerSocket; importação java.net.Socket; classe pública SocketServerTest {int PORT public static final = 8088; public static int CARTEIRA final = 2; public static void main (String [] args) throws IOException {server ServerSocket = new ServerSocket (PORT, a carteira); System.out.println ( "começou:" + servidor); try {Socket = server.accept (); try {BufferedReader in = new BufferedReader (new InputStreamReader (socket.getInputStream ())); Informações String = null;
while( ( info = in.readLine() ) != null )
{
System.out.println( info );
}
}
finally
{
socket.close();
}
}
finally
{
server.close();
}
}
}
Realizar o procedimento acima, depois de um tempo o programa é executado, a desconexão entre a conexão de rede cliente-servidor e, na saída da máquina é a seguinte:
Servidor na saída:
Repetindo: cliente enviou ----- hello0
Repetindo: cliente enviou ----- hello1
Repetindo: cliente enviou ----- hello2
Repetindo: cliente enviou ----- hello3
Repetindo: cliente enviou ----- hello4
Repetindo: cliente enviou ----- hello5
Repetindo: cliente enviou ----- hello6
Não existem dados de saída após a conexão de rede está desconectado ---- >>
Cliente na saída:
Tomada padrão timeout = 0
socket = soquete [addr = / 10.15.9.99, porta = 8088, localport = 4691]
começar a ler
enviado cliente --- Olá *** 0
enviado cliente --- Olá *** 1
enviado cliente --- Olá *** 2
enviado cliente --- Olá *** 3
enviado cliente --- Olá *** 4
enviado cliente --- Olá *** 5
enviado cliente --- Olá *** 6
enviado cliente --- Olá *** 7
enviado cliente --- Olá *** 8
enviado cliente --- Olá *** 9
cliente enviou --- Olá *** 10
---- >> desligado da rede depois de um processo de cliente é suspenso
java.net.SocketException : Conexão redefinida pelo peer: erro de gravação de soquete
em java.net.SocketOutputStream.socketWrite0 ( Método Nativo )
em java.net.SocketOutputStream.socketWrite ( SocketOutputStream.java:92 )
em java.net.SocketOutputStream.write ( SocketOutputStream.java:136 )
em sun.nio.cs.StreamEncoder.writeBytes ( StreamEncoder.java:202 )
em sun.nio.cs.StreamEncoder.implFlushBuffer ( StreamEncoder.java:272 )
em sun.nio.cs.StreamEncoder.implFlush ( StreamEncoder.java:276 )
em sun.nio.cs.StreamEncoder.flush ( StreamEncoder.java:122 )
em java.io.OutputStreamWriter.flush ( OutputStreamWriter.java:212 )
em java.io.BufferedWriter.flush ( BufferedWriter.java:236 )
em com.xtera.view.SocketClientTest.main ( SocketClientTest.java:99 )
Quando o hello6 do lado do servidor é transmitido para a conexão de rede está desligado, então o lado do servidor não pode receber quaisquer dados pendentes. terminal do cliente continua a dados de transmissão, de fato hello7, hello8, hello9, hello10 sendq são copiados para a fila, método de gravação retorna imediatamente. Uma vez que a fila do cliente está cheio sendq, método de gravação será bloqueado. Depois que o módulo TCP envia pacotes hello7, nós não receber a retransmissão tempo limite de reconhecimento, retransmitir várias vezes depois de fechar a conexão TCP, enquanto causando anormais método de gravação retorna bloqueado.
Através da ferramenta de captura de pacotes, podemos ver que os pacotes de retransmissão timeout.
