Thread quitte prématurément

Question

J'ai un serveur Bodi que je cours et il continue à sortir sur une certaine ligne comme si la fonction sortait en avance sur le calendrier. Je suppose ici (après avoir essayé Eclipse et NetBeans avec le même problème) que c'est la nature programmatique de la cause. Le thread parent interroge checkinputqueue() et checkoutputqueue() et ceux-ci vérifient à leur tour s'il existe des données que le serveur doit signaler comme étant prêtes à être traitées.

Un serveur Bodi est un serveur d'objets partagés. Vous pouvez demander à un JVM local d'obtenir un objet et obtenir une référence statique ou, à distance, une autre JVM peut être demandée pour un objet et vous obtiendrez une référence d'objet à lancer.

Impossible de le faire fonctionner. Pouvez-vous aider les gars? Le problème principal est le thread qui se termine avant la fin de la méthode readLine(). L'appel à readLine() quitte simplement la session du débogueur comme s'il n'y a plus d'exécution à tracer!?!?

/* 
* To change this license header, choose License Headers in Project Properties. 
* To change this template file, choose Tools | Templates 
* and open the template in the editor. 
*/ 

package apml.system.bodi.remote; 

/** 
* 
* @author Max Rupplin 
*/ 

class Listenerthread extends Thread 
{ 
public volatile Connection connection; 

public Boolean running = true; 

//public Basicserver server; 

public volatile Inputlistenerthread inputlistenerthrread; 

public volatile Outputlistenerthread outputlistenerthread; 

public Listenerthread(Connection connection) 
{ 
    this.connection = connection; 

    /*---------------------------------------------------------------------*/ 

    this.setName("Listenerthread"); 

    /*---------------------------------------------------------------------*/ 

    this.inputlistenerthrread = new Inputlistenerthread(this); 

    this.inputlistenerthrread.start();   

    /*---------------------------------------------------------------------*/ 

    this.outputlistenerthread = new Outputlistenerthread(this);     

    this.outputlistenerthread.start(); 
} 

@Override 
public void run() 
{ 
    System.out.println("> Server main thread started..."); 

    while(running)    
    { 
     System.err.println("Listner thread now looping..."); 

     try 
     { 
      synchronized(this.inputlistenerthrread.lock) 
      { 
       if(this.inputlistenerthrread.hasreadready) 
       {      
        this.inputlistenerthrread.checkinputqueue();       

        this.connection.isdonereading = true; 
       } 
      } 

      synchronized(this.outputlistenerthread.lock) 
      { 
       if(this.outputlistenerthread.haswriteready) 
       { 
        this.outputlistenerthread.checkoutputqueue(); 

        this.connection.isdonewriting = true; 
       } 
      } 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      try 
      { 
       Thread.sleep(400); 
      } 
      catch(InterruptedException ie) 
      { 
       running = false; 
      } 
      catch(Exception e) 
      {      
       e.printStackTrace();           
      } 
     } 
    } 

    System.out.println("Basicserver listener thread exiting..."); 
}  
} 

/----/

package apml.system.bodi.remote; 

/** 
* 
* @author Max Rupplin 
*/ 
class Inputlistenerthread extends Thread 
{ 
public Boolean hasreadready = false; 

public Boolean isnotchecking = true; 

public Boolean running = true; 

public volatile Listenerthread parent; 

public volatile Object lock = new Object(); 

public Inputlistenerthread(Listenerthread parent) 
{ 
    this.parent = parent; 

    this.setName("Inputlistenerthread");     
} 

public Boolean checkinputqueue() 
{     
    synchronized(this.lock) 
    {  
     StringBuffer inputbuffer = new StringBuffer(); 

     try 
     {  
      //this.lock.wait();       

      String line = null;         

      while((line = this.parent.connection.reader.readLine()) != null) 
      { 
       inputbuffer.append(line); 

       this.parent.connection.isdonereading = false; 
      } 

      if(inputbuffer.toString().length()>0) 
      { 
       this.parent.connection.inqueue.append(inputbuffer); 

       this.parent.connection.server.inputqueue.add(this.parent.connection);          

       this.parent.connection.hasreadready = true; 

       this.parent.connection.isdonereading = true;  
      }         
     } 
     catch(Error e) 
     { 
      e.printStackTrace(); 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      inputbuffer = null; 

      //this.lock.notifyAll(); 
     }   

     return true;    
    } 
} 

@Override 
public void run() 
{ 
    System.out.println("> Inputlistenerthread started..."); 

    try 
    { 
     while(running) 
     {     
      try 
      { 
       //if(this.parent.server.reader.lines().count()>0 || true) 
       if(true) 
       { 
        this.hasreadready = true; 
       } 
      } 
      catch(Exception e) 
      { 
       e.printStackTrace(); 
      } 
      finally 
      { 
       Thread.currentThread().sleep(250); 
      } 
     } 
    } 
    catch(Exception e) 
    { 
     e.printStackTrace(); 
    } 
} 

}

Answer 1

Vous devez regarder dans un débogueur, mais les lignes que vous montrer en commentaire

//this.lock.wait(); 

sont cruciales pour maintenir le fil en cours jusqu'à ce qu'il y ait quelque chose à traiter. Sinon, il n'y a rien à faire (la file d'attente est vide) et le thread sort en effet immédiatement.