Newsgroup: it.comp.java
Titolo: Per esperti (e pazienti): SOCKET

Sono bloccato perché incorre una anomalia inspiegabile (spero solo per me).
Allora:
Il mio SERVER genera un ThreadServer per ogni client che si collega. Dopo un
primo scambio di parametri fra un nuovo client ed il corrispettivo
threadserver tramite OBJECT(input/output)STREAM in un regime di spudorato,
ma nel mio caso necessario, busy-waiting, nei clients giungo in un
WHILE(true) in cui attendo all'infinito(!?) un VECTOR che, tramite un timer
presente nel threadserver corrispettivo, spedisco ogni 2 sec. Il problema
sorge proprio qui!!!
Premetto che il vector memorizza al suo interno i nomi dei clients connessi
al server. Al client1 connesso viene notificata la sua stessa
presenza(essendo del resto presente da solo), ma all'atto della connessione
del client2 a quest'ultimo giunge correttamente il vector con le due
presenze attuali (Client1 & Client2), ma al Client1 continua ad arrivare
ARCANAMENTE e MAGICAMENTE ancora il vector con solo una presenza dentro
(cioé la sua). Così via per un client3 ...
Allego il sorgente un pò rippato con le parti essenziali. Se qualcuno di
buona volontà avesse tempo di visionarlo e scovare l'inghippo, mi aiuterebbe
moltissimo.
Grazie
*******************************************
package myprojects.script;
import java.io.*;
import java.net.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.Timer;
class ServerThread extends Thread{
 public ServerThread(Socket socket, Canali c) throws IOException{
  this.socket = socket;
  this.chan = c;
  System.out.println("ServerThread "+id+": started");
  }//Costruttore
 public void run(){
  try{
  ObjectInputStream inobj = new ObjectInputStream(
   socket.getInputStream());
  ObjectOutputStream outobj = new ObjectOutputStream(
   socket.getOutputStream());
  Timer timer = new Timer(2000,new unlockClient(outobj));
  param = (parametri)inobj.readObject();
  System.out.println("Parametri nuovo client ricevuti");
    cnew.add(param);
    outobj.writeObject(new ack());
    System.out.println("Acknowledgement sent");
    outobj.flush();
    timer.start();
  }//try
  catch(IOException ie){ System.err.println("Comunicazione con il client
"+id+ " interrotta!");}
  catch(ClassNotFoundException cnf){}
 }//run()
  private class unlockClient implements ActionListener{
   public unlockClient(ObjectOutputStream outobj){
    this.outobj=outobj;
   }//Costruttore
   public void actionPerformed(ActionEvent event){
  try{
       Vector usersList = room.getList();
       outobj.writeObject(usersList);
       outobj.flush();
      }//try
    catch(IOException io){System.err.println("ECC");}
 }//actionperformed
  ObjectOutputStream outobj;
  }//unlockListener
private Socket socket = null;
private static int counter = 0;
private int id = ++counter;
private parametri param = null;
private Canali chan;
private chatroom cnew;
}//ServerThread
public class server{
   public static void main(String args[]) {
  routinServer();
 }//main
    private static void routinServer(){
  canali = new Canali();
   try{
  ServerSocket serverSocket = new ServerSocket(PORT);
  while(true){
   Socket clientsocket = serverSocket.accept();
   System.out.println('\n'+"Connessione stabilita");
   try{
      new ServerThread(clientsocket,canali).start();
      }
   catch(IOException e){
    System.out.println("Errore d'inizializzazione SERVER");
    }
     }//while(true)
   }//try
   catch(IOException e){
   System.err.println("Connessione fallita");
   System.exit(1);}
    }//routinserver
private static Canali canali;
private static final int PORT = 8989;
}//server
*******************************************
package myprojects.script;
import java.io.*;
import java.net.*;
import java.util.*;
public class client extends Thread{
  public client(String nick,String canale,String email,FrameBase frame){
 this.nick=nick;
 this.canale=canale;
 this.email=email;
 this.frame = frame;
 //start();
}//Costruttore
  public void run(){
   try{
  sock = new Socket("localhost",PORT);
  //Stream broadcast objects
  outobj = new ObjectOutputStream(sock.getOutputStream());
  inobj = new ObjectInputStream(sock.getInputStream());
  //Spedisco al Server i parametri di configurazione
  outobj.writeObject(new parametri(nick,canale,email));
  outobj.flush();
  System.out.println("Parametri spediti");
  //attendo acknowledgement dei parametri
  Object o = inobj.readObject();
  if (o instanceof ack){
   System.out.println("Accesso permesso al CLIENT");
   while(true){
   //IL PROBLEMA E' QUI !!
   Object msg = inobj.readObject();
   System.out.println("Vector"+": "+msg);
   Vector usersList = (Vector)msg;
   updateUsersList(usersList);
   }//while(true)
  }
 }//try
 catch(IOException e){}
 catch(ClassNotFoundException cnf){}
  }//run
  public void updateUsersList(Vector usersList){
   frame.model.clear();
   Iterator iter = usersList.iterator();
 while(iter.hasNext()){
   frame.model.addElement((String)iter.next());
 }//while
  }//updateUsersList
static final int PORT = 8989;
private String nick;
private String canale;
private String email;
private FrameBase frame;
private GregorianCalendar calendario;
private Socket sock=null;
private ObjectOutputStream outobj=null;
private ObjectInputStream inobj=null;
}//client


Purtroppo non ho molto tempo per leggere tutto il codice, ma forse ti posso
dare un suggerimento... hai usato "volatile" per gli oggetti condivisi di
cui conservi i riferimenti nei vari thread?
Ciao,
Luigi

 wrote in message
news:SFJia.2012$DT4....@twister1.libero.it...
