Kommunikation mit einem c-Prozess funzt nicht richtig

[horstboehse]

Hallo!

Ich habe ein Problem bei der Kommunikation mit einem aus Java heraus gestarteten Prozess über die Standardein- und ausgabe. Ich weiß, dass es dazu in diesem Forum eine Menge Beiträge gibt und ich habe mich schon durch sehr viel durchgewühlt. Leider löst keiner dieser Beiträge mein Problem.

Also, zu meinem Problem:

Ich habe ein kleines Testprogramm geschrieben, das einen Prozess startet. Anschließend holt es sich die Standardein- und ausgabestreams dieses Prozesses und startet 2 Hintergrundthreads. Einer fragt ständig den Inputstream ab, der andere den Errorstream. Aus Performancegründen habe ich Wartezeiten von 10ms eingebaut. Die Ergebnisse schreiben die Threads in ein Textfeld.

Über einen Send-Button wird andererseits ein String an den Outpustream des Prozesses gesendet. Auf diese Weise will ich mit dem Prozess kommunizieren.

Als Prozess habe ich mir in C 3 kleine Testprozesse geschrieben, bei denen das Javaprogramm stets unterschiedlich reagiert:

1. Der Prozess gibt in einer Endlosschleife etwas in die Standardausgabe aus.

Bei diesem Prozess funktioniert es, wie es soll. D.h. die Ausgabe des Prozesses erscheint im Textfeld der
Javaanwendung. Aufgrund der Endlosschleife ist der Prozessor natürlich voll ausgelastet

2. Wie bei 1., nur dass hier in jeder Iteration ein Sleep(11) eingebaut ist, so dass der Prozess nicht so viele
Ressourcen schluckt.

Hier funktioniert es leider nicht. Die Ausgabe des Prozesses erscheint nicht in dem Textfeld.

3. Dieser Prozess wartet auf eine Eingabe von der Standardeingabe. Anschließend wird ein Beep-Ton ausgegeben und
danach wird etwas auf der Standardausgabe ausgegeben. Dies passiert ebenfalls in einer Schleife.

Hier funktioniert nur das Senden an den Prozess. Denn nach dem Betätigen von "Send" ertönt der Beep-Ton. Es
erscheint jedoch keine Ausgabe im Textfeld.


Ich bin mit meinem Latein am Ende und weiß leider nicht mehr, woran es liegen könnte. Vielleicht kann mir ja jemand helfen.

Hier ein wenig Code:

public class Prozesstest 
extends JFrame
{
	
	//Textfelder für Ein- und Ausgabe
	JTextArea InputText;
	JTextField OutputText;
	
	//Prozess- und Threadvariablen
	Process proc;
	InputThread inputthread;
	InputThread errorthread;
	
	//Streams zur Kommunikation mit dem Prozess
	BufferedReader input;
	BufferedReader error;
	PrintStream output;
	
	public Prozesstest()
	{
		//GUI bauen
		super("Prozesstest");
		setLocation(200,200);
		setSize(640,480);
		setVisible(true);
		
		Container CPane = getContentPane();
		CPane.setLayout(new FlowLayout(FlowLayout.LEFT));
		
		//Inputextfeld bauen, scrollbar
		InputText = new JTextArea(20,55);
		JScrollPane scroll = new JScrollPane(InputText);
		//InputText.setBorder(BorderFactory.createEtchedBorder());
		CPane.add(scroll);
		
		//Outputtextfeld bauen
		OutputText = new JTextField(55);
		OutputText.setBorder(BorderFactory.createEtchedBorder());
		CPane.add(OutputText);
		
		//Button zum Senden an den Prozess
		JButton button = new JButton("Send");
		button.addActionListener(new Event());
		CPane.add(button);
		
		CPane.doLayout();
		
		addWindowListener(new WindowClosingAdapter());
	}
	
	public void StartProcess(String cmd)
	{
		try
		{
			//Starten des externen Prozesses
			proc = Runtime.getRuntime().exec(cmd);
			
			//Steams erzeugen
			input = new BufferedReader(new InputStreamReader(proc.getInputStream()));
			error = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
			output = new PrintStream(new BufferedOutputStream(proc.getOutputStream()), true);
			
			//Inputthread starten
			inputthread = new InputThread(input);
			inputthread.run();
			
			//Errorthread starten
			errorthread = new InputThread(error);
			errorthread.run();
			
		}
		catch(IOException e)
		{
			System.out.println("Fehler beim starten des Prozesses");
		}
	
		
	}
	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		//Instanz der Gui erzeugen
		Prozesstest ptest = new Prozesstest();
		
		//Prozess starten
		ptest.StartProcess("TestProzess2.exe");

	}
	
	class WindowClosingAdapter
	extends WindowAdapter
	{
		public void windowClosing(WindowEvent e)
		{
			try
			{
				//Inputthread beenden
				if(inputthread != null) 
				{
					inputthread.interrupt();
					inputthread.join();
				}
				//Errorthread beenden
				if(errorthread != null) 
				{
					errorthread.interrupt();
					errorthread.join();
				}
				//Process zerstören
				if(proc != null)
				{
					proc.destroy();
				}
			}
			catch(Exception ex)
			{
				System.out.println("Fehler beim Schließen");
			}
				
			System.exit(0);
		}
	}
	
	class Event
	implements ActionListener
	{

		@Override
		public void actionPerformed(ActionEvent e) 
		{
			if(e.getActionCommand().equals("Send"))
			{
				try 
				{
					//"hallo" an den Prozess senden
					output.println("hallo");
				} 
				catch (Exception e1) 
				{
					System.out.println("Fehler beim Senden an den Prozess");
				}
			}
		}
		
	}
	
	class InputThread
	extends Thread
	{
		//Zu überwachender Stream
		BufferedReader buffer;
		
		public InputThread(BufferedReader b)
		{
			buffer = b;
		}
		
		public void run()
		{
			try
			{
				//Für immer, wenn der Thread nicht beendet wird
				while(isInterrupted() == false)
				{
					//Solange etwas im Buffer ist und der Thread nicht beendet wird
					while(isInterrupted() == false && buffer.ready())
					{
						//Inhalt im Textfeld ausgeben
						InputText.append(buffer.readLine());
						InputText.append("\n");
						
					}
					
					//10ms warten, wegen der Performance
					sleep(10);
					
				}
				
				//Buffer schließen
				buffer.close();
			}
			catch(Exception e)
			{
				System.out.println("Fehler beim Thread");
			}
		}
	}

}

Danke schonmal im voraus!

 

[lhein]

Probier mal bitte folgendes:

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

public class Prozesstest 
extends JFrame
{
    //Textfelder für Ein- und Ausgabe
    JTextArea InputText;
    JTextField OutputText;
    
    //Prozess- und Threadvariablen
    Process proc;
    InputThread inputthread;
    InputThread errorthread;
    
    //Streams zur Kommunikation mit dem Prozess
    BufferedReader input;
    BufferedReader error;
    PrintStream output;

    boolean isAlive;
    
    public Prozesstest()
    {
        //GUI bauen
        super("Prozesstest");
        setLocation(200,200);
        setSize(640,480);
        setVisible(true);
        
        Container CPane = getContentPane();
        CPane.setLayout(new FlowLayout(FlowLayout.LEFT));
        
        //Inputextfeld bauen, scrollbar
        InputText = new JTextArea(20,55);
        JScrollPane scroll = new JScrollPane(InputText);
        //InputText.setBorder(BorderFactory.createEtchedBorder());
        CPane.add(scroll);
        
        //Outputtextfeld bauen
        OutputText = new JTextField(55);
        OutputText.setBorder(BorderFactory.createEtchedBorder());
        CPane.add(OutputText);
        
        //Button zum Senden an den Prozess
        JButton button = new JButton("Send");
        button.addActionListener(new Event());
        CPane.add(button);
        
        CPane.doLayout();
        
        isAlive = true;
        
        addWindowListener(new WindowClosingAdapter());
    }
    
    public void StartProcess(String cmd)
    {
        try
        {
            //Starten des externen Prozesses
            proc = Runtime.getRuntime().exec(cmd);
            
            //Steams erzeugen
            input = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            error = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
            output = new PrintStream(new BufferedOutputStream(proc.getOutputStream()), true);
            
            //Inputthread starten
            inputthread = new InputThread(input);
            inputthread.run();
            
            //Errorthread starten
            errorthread = new InputThread(error);
            errorthread.run();
            
        }
        catch(IOException e)
        {
            System.out.println("Fehler beim starten des Prozesses");
        }
    
        
    }
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        //Instanz der Gui erzeugen
        Prozesstest ptest = new Prozesstest();
        
        //Prozess starten
        ptest.StartProcess("TestProzess2.exe");

    }
    
    class WindowClosingAdapter
    extends WindowAdapter
    {
        public void windowClosing(WindowEvent e)
        {
            isAlive = false;
 
            try
            {
                //Inputthread beenden
                if(inputthread != null) 
                {
                    inputthread.interrupt();
                    inputthread.join();
                }
                //Errorthread beenden
                if(errorthread != null) 
                {
                    errorthread.interrupt();
                    errorthread.join();
                }
                //Process zerstören
                if(proc != null)
                {
                    proc.destroy();
                }
            }
            catch(Exception ex)
            {
                System.out.println("Fehler beim Schließen");
            }
                
            System.exit(0);
        }
    }
    
    class Event
    implements ActionListener
    {
        public void actionPerformed(ActionEvent e) 
        {
            if(e.getActionCommand().equals("Send"))
            {
                try 
                {
                    //"hallo" an den Prozess senden
                    output.println("hallo");
                } 
                catch (Exception e1) 
                {
                    System.out.println("Fehler beim Senden an den Prozess");
                }
            }
        }
        
    }
    
    class InputThread
    extends Thread
    {
        //Zu überwachender Stream
        BufferedReader buffer;
        
        public InputThread(BufferedReader b)
        {
            buffer = b;
            setDaemon(true);
        }
        
        public void run()
        {
            try
            {
                //Für immer, wenn der Thread nicht beendet wird
                while(isInterrupted() == false && isAlive)
                {
                    // something is readable - so read it
                    String data = "";
                    while (isAlive && (data = buffer.readLine()) != null)
                    {
                        final String line = new String(data);
                        //Inhalt im Textfeld ausgeben
                        SwingUtilities.invokeLater(new Runnable()
                        {
                            public void run()
                            {
                                InputText.append(line);
                                InputText.append("\n");
                                InputText.repaint();
                            }
                        });
                    }
                    
                    //10ms warten, wegen der Performance
                    sleep(10);                    
                }
                
                //Buffer schließen
                buffer.close();
            }
            catch(Exception e)
            {
                System.out.println("Fehler beim Thread");
            }
        }
    }

}

Und stell auch sicher, daß vom C-Prozess immer ein String gefolgt von einem Zeilenumbruch kommt.

lr

 

[horstboehse]

Danke erstmal für die schnelle Antwort!

Ich habe das jetzt mit deinem Quelltext getestet.

Zunächst dachte ich, dass sie das Problem löst, denn bei dem Prozess, der ständig Ausgaben tätitigt und dazwischen mit Sleep wartet, kam nach einiger Zeit die Ausgabe. Dann habe ich es nochmal mit meiner Quelle getestet und kam zu demselben Ergebnis. Ich hatte wahrscheinlich nur nicht lange genug gewartet.

Dabei wird die Ausgabe immer erst nach ca. 1000 Iterationen des Prozesses auf einmal ausgegeben. Woran liegt das denn? Wird immer zuerst der Puffer vollgeschrieben, bevor etwas ausgelesen werden kann?

Bei dem Prozess, der auf eine Eingabe wartet und erst dann eine Ausgabe tätigt, passiert leider immer noch nichts. Weder bei meiner Quelle, noch bei deiner. :-( Kann es vielleicht sein, dass die Ausgabe hier auch erst nach 1000 Iterationen kommt? Also, wenn ich 1000mal auf "Send" geklickt habe?

Geht das auch irgendwie so, dass ich die Ausgabe direkt empfange?

 

[lhein]

Probier mal beim output.println("hallo"); danach ein output.flush(); wenns sowas gibt.

Ansonsten verwendest Du halt einen Reader/Writer der ganze Lines sendet. Wenn Du jedes Zeichen lesen/schreiben willst, dann musst Du einen anderen Writer/Reader bzw. direkt den jeweiligen Stream benutzen.

lr

 

[horstboehse]

Ich habe das Problem gelöst.

Es lag nicht an Java, sondern am c-Prozess.
Scheinbar wird dort die Standardausgabe auch gepuffert und nur selten geflushed.

Ich habe dort jetzt nach jeder Ausgabe ein fflush(stdout) eingebaut.
Jetzt funktioniert es mit allen 3 Prozessarten tadellos.

Vielen Dank für die Denkanstöße!!

 

[lhein]

keine Ursache