Introduccin:

Los multihilos son un flujo de control secuencial dentro de un programa. Los que hemos
trabajado con UNIX estamos acostumbrados a la nocin de proceso y a su creacin o
eliminacin (kill). Un thread es, al igual que un proceso, un flujo de control que puede
gozar de cierta autonoma (puede tener sus propias estructuras de datos), pero a
diferencia de un proceso, diversos threads de una aplicacin pueden compartir los
mismos datos. A partir de ahora usaremos la expresin hilo como traduccin de thread.
Un hilo no puede correr por s mismo, se ejecuta dentro de un programa. Se pueden
programar mltiples hilos de ejecucin para que corran simultneamente en el mismo
programa. La utilidad de la programacin multihilos resulta evidente. Por ejemplo, un
navegador Web puede descargar un archivo de un sitio, y acceder a otro sitio al mismo
tiempo. Si el navegador puede realizar simultneamente dos tareas, no tendr que
esperar hasta que el archivo haya terminado de descargarse para poder navegar a otro
sitio. Asi como lo hemos implementado en nuestro programa cliente servidor.












Multihilo
Es una tcnica que permite que un programa o un proceso para ejecutar muchas tareas
simultneamente (al mismo tiempo y en paralelo). Permite que un proceso para ejecutar
sus tareas de forma paralela en un sistema de procesador nico
En Java, el Java Virtual Machine (JVM) permite que una aplicacin tiene mltiples hilos de
ejecucin que se ejecutan simultneamente. Permite que un programa sea ms
responsable ante el usuario.Cuando un programa contiene mltiples hilos, la CPU se
puede cambiar entre los dos hilos para ejecutar al mismo tiempo.
Por ejemplo, mire el diagrama que se muestra como:

Ventajas de los subprocesos mltiples en mltiples tareas:
Reduce el tiempo de clculo.
Mejora el rendimiento de una aplicacin.
Hilos comparten el mismo espacio de direcciones por lo que guarda la memoria.
El cambio de contexto entre los hilos es generalmente menos costosas que entre
los procesos.
El costo de la comunicacin entre hilos es relativamente bajo.
Diferentes estados de ejecucin de mltiples hilos son:


Un resumen de los mtodos tcpServer se ve as:


Resumen de los mtodos tcpServer
Mtodo Descripcin
actionPerformed
()
Este mtodo responde al botn de salida se pulsa en el marco
tcpServer.
cerrarConexion ()
se utiliza para cerrar la conexin de socket y los flujos de entrada /
salida.
principales () este es el punto de partida para la aplicacin de servidor.
ServerRun ()
este mtodo se utiliza para crear el socket de servidor, entrada / salida
y para escuchar de entrada de la toma.
tcpServer () este es el constructor de la clase utilizada para la inicializacin.
setThreadcount () El setThreadcount () mtodo restablece el nmero de subprocesos.
setUp () El mtodo setup () es la inicializacin de la aplicacin.
SYSEXIT ()
El mtodo SYSEXIT () es llamado en respuesta a un evento de cierre
de aplicaciones.
SYSPRINT () LLa mtodo SYSPRINT imprime mensajes de depuracin.
Figura 10: Resumen de los mtodos tcpServer

Resumen de los mtodos tcpClient
El Resumen de los mtodos tcpClient se muestran a continuacin.
Resumen de los mtodos tcpClient
Mtodo Descripcin
actionPerformed
()
Este mtodo responde a los botones de enviar, claro, o la salida se
pulsa en el marco tcpClient.
main () Este mtodo es el principal punto de entrada llamado por la JVM.
cerrarConexion ()
se utiliza para cerrar la conexin de socket y los flujos de entrada /
salida.
connect () este mtodo se utiliza para conectar a la toma.
runClient ()
este mtodo se utiliza para
1. Crear entrada / salida
2. Hacer peticiones al servidor en forma de mensajes enviados al
servidor
3. Preste atencin a la entrada de la toma.
setUp ()
este mtodo se utiliza para configurar y asignar los objetos de interfaz
grfica de usuario.
tcpClient () este es el constructor de la clase utilizada para la inicializacin.
Figura 13: Resumen de los mtodos tcpClient

Codigo:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package multihilos_cliente_servidor;

/**
*
* @author
*/
import java.net.*;
import java.io.*;

public class ChatClient{
private static final int PORT = 5320;
// private static final byte[] addr = {127, 0, 0, 0};
private Socket server;

public ChatClient(){
try{
// server = new Socket(InetAddress.getByAddress(addr), PORT);
server = new Socket(InetAddress.getLocalHost(), PORT);
System.out.println("Escriba 'exit' para salir.");

// leemos del teclado y lo mandamos al servidor.
Thread escritura = new Thread(){
public void run(){
try{
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
PrintWriter out = new PrintWriter( server.getOutputStream(), true );
boolean done = false;
while( !done ){
String line = in.readLine(); // leemos de consola.
out.println(line); // mandamos lo escrito al servidor.
if ( line == null || line.trim().equals("exit") )
done = true;}
}catch( IOException ioe ){
System.out.println("Error al escribir en el servidor " + ioe);}}};

// Obtenemos lo que nos mande el servidor, y lo mostramos en pantalla:
Thread lectura = new Thread(){
public void run(){
try{
BufferedReader svrStream = new BufferedReader(new
InputStreamReader(server.getInputStream()));
String svrResponse; boolean done = false;
do {
svrResponse = svrStream.readLine();
System.out.println(svrResponse);
if ( svrResponse.equals("Server: exit") || svrResponse == null ){
done = true;
System.out.println("Fin comunicacin");}
}while ( !done );
}catch( IOException ioe ){ System.out.println("Error al escuchar del servidor " + ioe); }}};

escritura.start();
lectura.start();
}catch( IOException ioe ){ System.out.println("Error al crear el socket " + ioe); }
}

public static void main(String args[]){
ChatClient cliente = new ChatClient();
}
}

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package multihilos_cliente_servidor;

/**
*
* @author
*/
import java.net.*;
import java.io.*;

public class ChatServer{
private static final int PORT = 5320;
private ServerSocket mServerSocket;
public ChatServer(){
System.out.println("Servidor listo");
// crea un thread para esperar nuevos clientes:
Thread daemon = new Thread(new Runnable(){
public void run(){
try{
// abre un socket en el servidor actual:
mServerSocket = new ServerSocket( PORT);

while (true){
// espera a que alguien se conecte:
Socket client = mServerSocket.accept();
// crea un thread para manejar a ese cliente:
ClientUser cu = new ClientUser(client);
cu.start();
}}catch(IOException e){
System.out.println("Error esperando conexiones: " + e);}}});

daemon.start(); }
public static void main( String args[] ){
ChatServer server = new ChatServer();}}

class ClientUser extends Thread{
Socket mClientSocket;

public ClientUser( Socket s ){ mClientSocket = s;}
public void run(){
try{

// obtiene streams de entrada y salida:
PrintWriter clientResponse = new
PrintWriter(mClientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new
InputStreamReader(mClientSocket.getInputStream()));

// mostramos mensaje de bienvenida:
System.out.println("Nuevo cliente conectado");
// leemos del cliente, hacemos echo en l:
while ( true )
{
String line = in.readLine();
clientResponse.println("Server: " + line);
System.out.println(line);

if ( line.trim().equals("exit") || line == null ){
break;}}}
catch(IOException ioe){ System.out.println("Error del cliente: " +
ioe); }
}}
Conclusin:
La programacin de hilos requiere un cambio en la forma de pensar al programar, ya que
la ejecucin del cdigo ya no se realiza de forma secuencial sino paralelamente. Tiene
suma importancia saber cundo hay que hacer uso de threads y cundo evitarlos. Las
principales razones de usarlos son al gestionar varias tareas que al entremezclarse hagan
un uso ms eficiente del ordenador, o porque al usuario le interese por una determinada
circunstancia. Un nico hilo es similar a un programa secuencial; es decir, tiene un
comienzo, una secuencia y un final, adems en cualquier momento durante la ejecucin
existe un slo punto de ejecucin. Sin embargo, un hilo no es un programa; no puede
correr por s mismo, corre dentro de un programa. Un hilo por si mismo no nos ofrece
nada nuevo, es la habilidad de ejecutar varios hilos dentro de un programa lo que ofrece
algo nuevo y til, ya que cada uno de estos hilos puede ejecutar tareas distintas. Una
ventaja de usar hilos es que las conmutaciones de contexto de procesos ligeras,
sustituyen a las conmutaciones de contexto de procesos pesadas. Debido a que todos los
hilos de un determinado proceso comparten el mismo espacio de memoria, una
conmutacin del proceso ligera slo cambia la ejecucin del programa y las variables
locales, mientras que una conmutacin de contexto pesada debe intercambiar todo el
espacio en memoria