Newsgroup: it.comp.java
Titolo: programma che non termina

ciao a tutti credo sia eloquente l'oggetto del msg infatti sarei grato
a chiunque sappia spiegarmi perchè il mio programma non termina il
codice,il codice  dialoga con il modem usando le java comm (scusate la
lunghezza del listato ma così se vi serve potreste usarlo anche voi):
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.TooManyListenersException;
import javax.comm.*;
/**
* Simple program to read characters from the command-line, send
* them to the specified serial port, and echo any characters
returned.
* Modeled after the SimpleRead and SimpleWrite sample programs
included
* with the Java Communications API distribution.
*/
 public class SimpleWrite1 implements Runnable,
SerialPortEventListener {
   static String DEFAULT_PORT = "COM4";
   InputStream  in;
   OutputStream out;
   private String message = "AT\r";
private Object readerThread;
   public void writeToCommPort(String message)  {
     this.message = message;
     Thread readerThread;
       }
 /**
  * Main method.
  */
    public static void main(String[] args) {
      String portname = DEFAULT_PORT;
      if (args.length > 1) {
         System.err.println("Usage: java SimpleReadWrite [port_name]");
         System.exit(1);
      }
      else if (args.length == 1) {
         portname = args[0];
      }
      try {
         CommPortIdentifier portId =
CommPortIdentifier.getPortIdentifier(portname);
         if (portId.getPortType() ==
CommPortIdentifier.PORT_SERIAL) {
            SimpleReadWrite1 srw = new SimpleReadWrite1(portId);
         }
         else {
            System.err.println(portname + " is not a serial port");
            System.exit(1);
         }
      }
          catch (NoSuchPortException e) { //Port nicht vorhanden
            System.err.println("No such port: " + portname);
            System.exit(1);
         }
          catch (PortInUseException e) { //Port ist gesperrt/inGebrauch
            System.err.println("Port in use: " + portname);
            System.exit(1);
         }
   }
 /**
  * Constructor.
  */
    public SimpleWrite1(CommPortIdentifier portId) throws
PortInUseException {
      try {
         SerialPort serialPort = (SerialPort)
portId.open("SimpleReadWrite",
                                                          2000);
//Port mit
         in  = serialPort.getInputStream();
         out = serialPort.getOutputStream();
         serialPort.addEventListener(this);
         serialPort.notifyOnDataAvailable(true);
         serialPort.setSerialPortParams(9600,
//Schnittstelleneinstellungen initialisieren
                                        SerialPort.DATABITS_8,
                                        SerialPort.STOPBITS_1,
                                        SerialPort.PARITY_NONE);
         Thread readerThread = new Thread(this);
         readerThread.start();
      } //Exception-Handling
          catch (IOException e) {
            System.err.println("Problem opening streams");
            System.exit(1);
         }
          catch (TooManyListenersException e) {
            System.err.println("Too Many Listeners");
            System.exit(1);
         }
          catch (UnsupportedCommOperationException e) {
            System.err.println("Problem setting port parameters");
            System.exit(1);
         }
   }
 /**
  * This method loops forever, reading data from the
  * command line and writing it directly to the serial port.
  * No buffering is performed.
  */
    public void run() {
      try {
           out.write(message.getBytes());
      }
          catch (IOException e) {
         // Terminate thread
         }
   }
 /**
  * Process serial port events.  This method is required
  * when implementing SerialPortEventListener
  *
  * @param event SerialPortEvent object to process
  */
    public void serialEvent(SerialPortEvent event) {
      switch (event.getEventType()) {
         case SerialPortEvent.BI:
         case SerialPortEvent.OE:
         case SerialPortEvent.FE:
         case SerialPortEvent.PE:
         case SerialPortEvent.CD:
         case SerialPortEvent.CTS:
         case SerialPortEvent.DSR:
         case SerialPortEvent.RI:
         case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            break;
         case SerialPortEvent.DATA_AVAILABLE:
             // If there is data available on serial port,
             // read it in in chunks <=20 bytes
             //
            byte[] readBuffer = new byte[1];
            try {String l;
               while (in.available() >0 && (in.read())!=0) {
                  int numBytes = in.read(readBuffer);
                  in.close();
               }
               System.out.write(readBuffer);
            }
                catch (IOException e) {
                 // Terminate handling this event on read error
               }
            break;
         default:
            System.out.print("Unknown SerialPortEvent type = " +
                              event.getEventType());
            break;
      }
   }
}

 lunghezza del listato ma così se vi serve potreste usarlo anche voi):
Il programma termina quando tutti i thread non-daemon sono terminati. 
Quindi, o trasformi il thread in daemon (setDaemon(true)) e subordini la 
chiusura del programma alla chiusura del thread principale, oppure fai 
in modo che il thread principale faccia terminare tutti gli user-thread 
prima di uscire.

grazie per la risposta quindi dovrei scrivere dopo : Thread
readerThread = new Thread(this); setDaemon(true); e scrivere la
siqnature di questo metodo altrimenti   in che modo il thread
principale fa terminare tutti gli user-thread
prima di uscire. scusa per la semplicità ma nonostante le mie molte
letture sui thread mi trovo in difficoltà e la mia tesi ne risente

riccardo wrote:

I thread "muoiono" nel momento in cui escono (sia per azione di una 
return che per una eccezione) dal metodo run(). Il thread principale 
dovrebbe semplicemente impostare una proprietà del thread da terminare e 
quest'ultimo dovrebbe educatamente uscire quando vede cambiata la proprietà.
Se il thread è fermo in una operazione bloccante, aspetta che abbia 
finito. Se ciò non è applicabile (il blocco è a tempo indeterminato) 
allora vuol dire che è giusto impostare il thread a daemon.

io o dichiarato ilmio thread daemon ma non si blocca ho anche questo
Thread [Win32SerialPort Notification thread] in esecuzione sara lui che
dà problemi e non quello che io ho dichiarato ho detto panzane?