OOOk....
Allora classe myThread:
codice:
 import java.net.*;
 import java.io.*;

 public class myThread extends Thread {
	//ATTRIBUTI
		//Variabile socket per assegnarlo al processo.
			private Socket sok;
		//Variabili per i canali di input e output.
			private BufferedReader in;
			private BufferedWriter out;
		//Variabile flag per stampe d'errore.
			private boolean control=true;
			
	//METODO COSTRUTTORE con assegnazione del socket al processo.
    	
	    	public myThread(Socket sokcet) {
	    		try{
	    			this.setSocket(sokcet);
	    				if(control)
	    					System.out.println("Il SOCKET è stato assegnato al processo.");
	    		}catch(Exception e){
    				if(control)
    					System.out.println("ERR Il SOCKET non è stato assegnato al processo.");
	    		}
	    	}
    
    	//Metodi per l'apertura dei canali.
    		public void openInBus(){
				try{
					in=new BufferedReader(new InputStreamReader(getSocket().getInputStream()));
						if(control)
							System.out.println("Il canale IN del processo è stato APERTO.");
				}catch(Exception e){
					if(control)
    					System.out.println("ERR Il canale IN del processo non è stato APERTO.");
				}
    		}    	
    		public void openOutBus(){
				try{
    				out=new BufferedWriter(new OutputStreamWriter(getSocket().getOutputStream()));
    					if(control)
							System.out.println("Il canale OUT del processo è stato APERTO.");
				}catch(Exception e){
					if(control)
						System.out.println("ERR Il canale OUT del processo non è stato APERTO.");
				}
    		}    	
    	//Metodi per la chiusura dei canali.
    		public void closeInBus(){
				try{
					in.close();
						if(control)
							System.out.println("Il canale IN del processo è stato CHIUSO.");
				}catch(Exception e){
					if(control)
    					System.out.println("ERR Il canale IN del processo non è stato CHIUSO.");
				}
    		}
    		public void closeOutBus(){
				try{
    				out.close();
    					if(control)
    						System.out.println("Il canale OUT del processo è stato CHIUSO.");
				}catch(Exception e){
					if(control)
    					System.out.println("ERR Il canale OUT del processo non è stato CHIUSO.");
				}
    		}
    //METODI TRASMISSIONE
    	//Metodo per scrivere sul canale.
    		public void write(String mex){
    			try{
                                openOutBus(); //Apro il canale per scrivere
    				out.write(mex);
    				out.flush();
                                closeOutBus(); //Chiudo il canale senno si impalla sulla readLine()
    					if(control)
    						System.out.println("SCRITTO sul canale.");
    			}catch(Exception e){
    				if(control)
						System.out.println("ERR non SCRITTO sul canale.");
    			}
    		}
    	//Metodo per leggere sul canale.
    		public String read(){
    			String mex=null;
    			try{ 		
                                openInBus();
    				mex=in.readLine();
                                closeInBus(); //Chiudo il canale senno si impalla sulla readLine()
    					if(control)
    						System.out.println("LETTO sul canale.");
    			}catch(Exception e){
    				if(control)
						System.out.println("ERR non LETTO sul canale.");
    			}
    			return mex;
    		}
    //METODO RUNNABLE
		     public void run(){     	
		     }
Poi c'è la classe client:

codice:
import java.net.*;

public class Client {
	//ATTRIBUTI.
		//Oggetto Socket per client.
			private Socket client;
		//Processo per assegnare il client.
			private myThread taskClient;
		//Variabile flag per stampe d'errore.
			private boolean control=true;
			
	//METODO COSTRUTTORE
		/*Effettua la connessione al server e assegna il client al processo.*/
			
			public Client(String ipServer, int port) {
				try {
					client=new Socket(ipServer,port);
						if(control)
							System.out.println("Il SOCKET CLIENT si è connesso al server.");
				}catch (Exception e) {
					if(control)
						System.out.println("ERR Il SOCKET CLIENT non si è connesso al server.");
				}
				taskClient=new myThread(client);
				taskClient.start();
			}
	//METODI CLASSE
		//METODO SCRIVI sul canale.
			public void write(String mex){
				try{
					taskClient.write(mex);
						if(control)
							System.out.println("Il socket client ha SCRITTO sul canale.");
				}catch(Exception e){
					if(control)
						System.out.println("ERR Il socket client non ha SCRITTO sul canale..");
				}
			}
		//METODO LEGGI sul canale.
			public String read(){		
				String mex="";
					try{		
						mex=taskClient.read();
							if(control)
								System.out.println("Il socket client ha LETTO sul canale.");
					}catch(Exception e){
						if(control)
							System.out.println("ERR Il socket client non ha LETTO sul canale..");
					}
				return mex;
			}
e quella server

codice:
import java.io.*;
import java.net.*;

public class Server extends Thread{
	//ATTRIBUTI
		//OggettoServerSocket.
			private ServerSocket server;
		//Array di 5 Oggetti 'myThread'			che simulano i processi per ogni client connesso.
			private myThread clients[];
		//Indice utile per l'array di clients.
			private int index;
		//Variabile flag per stampe d'errore.
			private boolean control=true;
			
	//METODO COSTRUTTORE
		/*Mette in ascolto il server sulla porta 'port'
		Assegna il server ad un processo in modo da
		tenerlo indipendente dai processi dei clients*/
			
			public Server(int port){
				//Connessione alla porta.
				try {
					server = new ServerSocket(port);	
						if(control)
							System.out.println("Il SERVER si è connesso alla porta.");
				} catch (Exception e) {		
					if(control)
						System.out.println("ERR Il SERVER non si è connesso alla porta.");
				}
				//Creazione 5 processi per socket.
				clients=new myThread[5];
				//Assegnazione server al processo.
				super.start();
				setIndex(0);
			}
	//METODI CLASSE
		//METODO GET e SET INDEX
			private void setIndex(int index) {
				this.index = index;
			}
			public int getIndex() {
				return index;
			}
		//METODO CONNESSIONE.
			public boolean connection(){
				Socket sTemp;
					while(index<1){
						try {
							if(control)
								System.out.println("Il SERVER è in ascolto sulla porta....");
								sTemp=server.accept();
									if(control)
										System.out.println("Il SERVER ha accettato un client");
							clients[index]=new myThread(sTemp);
							clients[index].start();
							index++;							
						}catch (IOException e) {
							if(control)
								System.out.println("ERR Il SERVER non ha accettato un client.");
							return false;
						}
					}
					if(control)
						System.out.println("Il SERVER ha accettato il numero massimo di clients");
				return true;
			}
		//METODO SCRIVI sul canale ad un determinato client.
			public void write(String mex, int index){
				try{
					clients[index].write(mex);
						if(control)
							System.out.println("Il SERVER ha SCRITTO al client n"+index);
				}catch(Exception e){
					if(control)
						System.out.println("ERR Il SERVER non ha SCRITTO al client n"+index);
				}
			}
		//METODO SCRIVI sul canale a tutti i client.
			public void write(String mex){
				try{
					write(mex,0);
					write(mex,1);
					write(mex,2);
					write(mex,3);
					write(mex,4);
						if(control)
							System.out.println("Il SERVER ha SCRITTO a tutti i clients.");
				}catch(Exception e){
					if(control)
						System.out.println("ERR Il SERVER non ha SCRITTO a tutti il clients.");
				}
			}
		//METODO LEGGI dal canale di un determinato client.
			public String read(int index){
				String mex="";
					try{		
						mex=clients[index].read();
							if(control)
								System.out.println("Il SERVER ha LETTO dal client n"+index);
					}catch(Exception e){
						if(control)
							System.out.println("ERR Il SERVER non ha LETTO dal client n"+index);
					}
				return mex;
			}
		//METODO RUNNABLE.
			public void run(){
			}