# Swinganwendung Threads mit JProgressBar



## mike66 (16. Jun 2006)

Hi,

habe hier ne etwas spezielle Aufgabe und komm nicht weiter...   Das Endprodukt soll so aussehen:






Dabei soll folgende Klassenstruktur verwendet werden:





Das Programm erwartet zunächst drei Parameter und wandelt diese in int um, diese werden den Threads
als Verzögerung übergeben Thread.sleep(delay);... Die drei Threads zählen dann mit dem jeweiligen delay
von 0 auf 100 hoch und geben einen Meldung aus wenn Sie 100 erreicht haben, zusätzlich wird mit ange-
zigt wie oft welcher Thread die 100 erreicht hat... soweit läuft das schon mal auf der Konsole   

Nun soll das ganze noch in einem Swingfenster (img1) unter Berücksichtigung der obigen Klassenstruktur
(img2) dargestellt werden.

Und genau da verliessen Sie ihn... anbei mein unfertiger und leider fehlerhafter Lösungsansatz  ???:L

ThreadInfoPanel, ThreadProgressPanel u. ButtonPanel sollen hier im Sinne der OO nur jeweils ein
Exemplar bereitstellen und dementsprechend im Swingfenster angezeigt werden. Wobei noch ein
img (img1 - grünes Quadrat) anzeigen soll wann welcher Thread aktiv ist... über den Beenden Button
soll das Fenster geschlossen werden.
Über "Threads abbrechen" soll in TeilB der Aufgabe die Threads in einer ThreadGroup angelegt und
über einen ActionListener gestoppt werden. 

Der Aufruf der Threads soll über eine Schleife im Konstruktor von MyFrame erfolgen. Den Threads
werden dann der Name, die Verzoegerungszeit, die beiden zugehoerigen JPanels als Parameter
übergeben. Die Threads rufen dann die Methoden der JPanels auf, um selbststaendig die Informationen
über ihren Status zu aktualisieren.

    for (int i=0; i<3; i++)
    {

      threadArray_ = new Thread(new MyThread("Thread " + (i + 1), delay,
                                  infoPanel, progressPanel));
      threadArray.start();
    }

**** Hier steck ich schonmal fest und bekomm folgende Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
	at MyFrame.<init>(MyFrame.java:54)
	at Aufgabe4.<init>(Aufgabe4.java:78)
	at Aufgabe4.main(Aufgabe4.java:58)


Bin dankbar für jeden Hinweis   

Grüße




		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;


public class Aufgabe4 extends Object
{
  /*
    Erfuellt folgende Anforderungen:
    - Pruefung, ob drei Befehlszeilen-Parameter eingegeben wurden
    - Pruefung, ob drei ganze (Integer) Zahlen eingegeben wurden
      Im Fehlerfall wird ein Dialogfeld mit entsprechender Nachricht
      dargestellt und das Programm beendet
    - Ausgabe der drei Zahlen in einem Dialogfeld
    - Instanziierung und Starten der drei Threads
  */

  public final static int WINSCORE = 100; // Highscore
  private MyThread topThread, middleThread, bottomThread;

  public static void main(String[] args)
  {
    int[] params = new int[3]; // Array fuer die drei int Parameter
  
    // Pruefen, ob genau drei Parameter eingegeben wurden
    if (args.length != 3)
    {
      String s = "Bitte geben Sie drei ganze Zahlen als Parameter an." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Pruefen, ob die drei Strings Integers sind
    try
    {
      for (int i = 0; i < 3; i++)
      {
        params[i] = Integer.parseInt(args[i]);
      }
    }
    catch (NumberFormatException e)
    {
      String s = "Mindestens einer der angegebenen Parameter ist keine ganze Zahl." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Alles in Ordnung -> Ausgabe der Parameter
    String s = "Die eingegebenen Werte sind:\n" + params[0] + ", " + params[1] + " und " + params[2];
    JOptionPane.showMessageDialog(null, s, "Information", JOptionPane.INFORMATION_MESSAGE);

    // Aufrufen des Konstruktors zur Gernerierung der Threads
    // Grund: in einer statischen Methode wie z.B. main kann man
    // nur statische Objekte und Variablen verwenden.
    new Aufgabe4(params);
  
    //MyFrame frame = new MyFrame();
	// frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
    //frame.setVisible(true);
  }
  

  public Aufgabe4(int[] delay) 
  {
	
	topThread = new MyThread("Top-Thread", delay[0], null, null);
    new Thread(topThread).start();
    middleThread = new MyThread("Middle-Thread", delay[1], null, null);
    new Thread(middleThread).start();
    bottomThread = new MyThread("Bottom-Thread", delay[2], null, null);
    new Thread(bottomThread).start();
    
    
    // Erstellung des Fensters zur Anzeige der Threads
    MyFrame frame = new MyFrame(delay);
    frame.setVisible(true);
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.BorderLayout;import javax.swing.*;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class MyFrame extends JFrame implements ActionListener
{
	  //private JButton exitButton;
	  public JLabel inIPanel;
	  private JProgressBar pbFortschritt;
	  private JButton btEnde;
	  private int MyThread;
	  
	  
	  public MyFrame(int[] delay){
		setTitle("Threads");
		setSize(800, 500);
		//exitButton = new JButton("Beenden");
				
		Container inhalt = getContentPane();
		inhalt.setLayout(new GridLayout(7, 1));
		
		//inhalt.add(exitButton, "South");
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ButtonPanel(btEnde));
		
		// btEnde.addActionListener(this);
		//btEnde.addActionListener(this);
		//exitButton.addActionListener(this);
		
		// Error - java.lang.ArrayIndexOutOfBoundsException
		Thread[] threadArray = new Thread[MyThread];
			for (int i=0; i<3; i++)
			{
				threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], null, null));
		/*		
		threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], 
				inIPanel[i], progressPanel[i]));
		*/
				threadArray[i].start();
			}		
	  
	  }
	  
	  

	// ActionEvent
	  public void actionPerformed(ActionEvent event){
		// beendenButton Ereignis
		Object source = event.getSource();
		//if (source == exitButton) System.exit(0);
		
		if (source == btEnde) System.exit(0);
	  }
}




		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;

public class MyThread extends Object implements Runnable
{
  private String name;
  private int delay;
  private int points = 0;  // Laeuft von 0 bis 100
  static int wins = 0;    // Zaehlt die einzelnen Laeufe bis 100

  public MyThread(String inName, int inDelay, ThreadInfoPanel inIPanel, ThreadProgressPanel inPPanel)
  {
    this.name = inName;
    this.delay = inDelay;
    inIPanel = inIPanel;
    inPPanel = inPPanel;
  }

  

public void run()
  {
    try
    {
      for (;;) // absichtliche Endlosschleife :)
      {
	    points ++;
	    final int j = points;
	    //pbFortschritt.setValue(points);
	    
	    // pbFortschritt.setValue(i);
	    // Konstante in der Hauptklasse abfragen
	    if (points == Aufgabe4.WINSCORE)
	    {
	      wins ++;
                    
              // Ausgabe der Gewinne auf Kommandozeilenebene
              String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                      + " - " + wins + " Mal erreicht.";
	      System.out.println(s);
	      points = 0;
	    }
        
        // Thread legt sich fuer seine Verzoegerungsdauer schlafen
        Thread.sleep(delay);
      }
    }
    catch (InterruptedException e) { return; }
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;

class ThreadInfoPanel extends JPanel
{
  // JLabel jlInfo gibt Info ueber: name, delay, points, WINSCORE
  public ThreadInfoPanel(JLabel inIPanel)
  {
	inIPanel = new JLabel();
	setLayout(new FlowLayout(FlowLayout.LEFT));
    add(inIPanel);
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;

import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JPanel;

class ThreadProgressPanel extends JPanel
{
  // Enthaelt ProgressBar für topThread, middleThread, bottomThread
  public ThreadProgressPanel(JProgressBar pbFortschritt)
  {
	pbFortschritt = new JProgressBar(0, 100);
	pbFortschritt.setStringPainted(true);
	setLayout(new FlowLayout(FlowLayout.CENTER));
    add(pbFortschritt);
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JPanel;

class ButtonPanel extends JPanel
{
  // Enthaelt die Schaltflaeche "Beenden" in einem FlowLayout
  public ButtonPanel(JButton btEnde)
  {
	btEnde = new JButton("Beenden");
	setLayout(new FlowLayout(FlowLayout.RIGHT));
    add(btEnde);
  }
}

_


----------



## Timmah (16. Jun 2006)

[
	
	
	
	





```
// Error - java.lang.ArrayIndexOutOfBoundsException
      Thread[] threadArray = new Thread[MyThread];
         for (int i=0; i<3; i++)
         {
            threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], null, null));
      /*      
      threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i],
            inIPanel[i], progressPanel[i]));
      */
            threadArray[i].start();
         }
```


Also du willst ein Array von Threads erzeugen, und musst demnach bei new Thread[] eine Größe mit angeben und kein Objekt von MyThread, also demnach new Thread[DEINE_GROESSE].

Dann musst du bei

```
threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], null, null));
```

nur threadArray_ = new MyThread(...)

angeben.

Stell das erstmal richtig, und dann sehen wir weiter 

Achja, dann muss natürlich MyThread auch von Thread erben und nicht nur Runnable implementieren._


----------



## mike66 (17. Jun 2006)

Hi Timmah,

danke für Deine Hilfe, das sieht nun schon viel besser aus  :applaus: 

Leider häng ich nun bei Array fest... es sollten nun weitere Parameter übergeben und entprechend
die Konstruktoren angepasst werden, aber da komm wieder ich auf keinen grünen Zweig  

for (int i=0; i<3; i++)
    {

      threadArray_ = new Thread(new MyThread("Thread " + (i + 1), delay,
*infoPanel, progressPanel)*);
      threadArray.start();
    }


Im Moment laufen die Threads aus dem Array auf der Konsole, allerdings wird WINSCORE allen
Threads zugeordnet...

Thread 1 mit 50 ms Verzoegerung hat 100 - 1 Mal erreicht.
Thread 2 mit 60 ms Verzoegerung hat 100 - 2 Mal erreicht.
Thread 3 mit 70 ms Verzoegerung hat 100 - 3 Mal erreicht.
Thread 1 mit 50 ms Verzoegerung hat 100 - 4 Mal erreicht.
Thread 2 mit 60 ms Verzoegerung hat 100 - 5 Mal erreicht.
Thread 3 mit 70 ms Verzoegerung hat 100 - 6 Mal erreicht.
Thread 1 mit 50 ms Verzoegerung hat 100 - 7 Mal erreicht.
....

Hast Du ne Idee was die Parameter und WINSCORE angeht?

Vielen Dank erstmal   






		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;


public class Aufgabe4 extends Object
{
  public final static int WINSCORE = 100; // Highscore
  private MyThread topThread, middleThread, bottomThread;

  public static void main(String[] args)
  {
    int[] params = new int[3]; // Array fuer die drei int Parameter
  
    // Pruefen, ob genau drei Parameter eingegeben wurden
    if (args.length != 3)
    {
      String s = "Bitte geben Sie drei ganze Zahlen als Parameter an." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Pruefen, ob die drei Strings Integers sind
    try
    {
      for (int i = 0; i < 3; i++)
      {
        params[i] = Integer.parseInt(args[i]);
      }
    }
    catch (NumberFormatException e)
    {
      String s = "Mindestens einer der angegebenen Parameter ist keine ganze Zahl." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Alles in Ordnung -> Ausgabe der Parameter
    String s = "Die eingegebenen Werte sind:\n" + params[0] + ", " + params[1] + " und " + params[2];
    JOptionPane.showMessageDialog(null, s, "Information", JOptionPane.INFORMATION_MESSAGE);

    // Aufrufen des Konstruktors zur Gernerierung der Threads
    // Grund: in einer statischen Methode wie z.B. main kann man
    // nur statische Objekte und Variablen verwenden.
    new Aufgabe4(params);
  }
  

  public Aufgabe4(int[] delay) 
  {
    // Erstellung des Fensters zur Anzeige der Threads
    MyFrame frame = new MyFrame(delay);
    frame.setVisible(true);
  }
}





		Code:In die Zwischenablage kopieren


import java.awt.BorderLayout;import javax.swing.*;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class MyFrame extends JFrame implements ActionListener
{
	  //private JButton exitButton;
	  public JLabel inIPanel;
	  public JProgressBar pbFortschritt;
	  private JButton btEnde;
	  private int MyThread;
	  
	  
	  public MyFrame(int[] delay){
		setTitle("Threads");
		setSize(800, 500);
		//exitButton = new JButton("Beenden");
				
		Container inhalt = getContentPane();
		inhalt.setLayout(new GridLayout(7, 1));
		
		//inhalt.add(exitButton, "South");
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ThreadInfoPanel(inIPanel));
		inhalt.add(new ThreadProgressPanel(pbFortschritt));
		
		inhalt.add(new ButtonPanel(btEnde));
		
		// btEnde.addActionListener(this);
		// exitButton.addActionListener(this);
		
		// Array von Threads erzeugen
		Thread[] threadArray = new Thread[3];
			for (int i=0; i<3; i++)
			{
				threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], null, null));
				threadArray[i].start();
				
				//infoPanel[i], progressPanel[i]));
				
				String s = " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                + " -  Mal erreicht.";
				System.out.println(threadArray[i]);
			}		
	  }
	  
	  

	// ActionEvent
	  public void actionPerformed(ActionEvent event){
		// beendenButton Ereignis
		Object source = event.getSource();
		//if (source == exitButton) System.exit(0);
		
		if (source == btEnde) System.exit(0);
	  }
}




		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;

public class MyThread extends Thread implements Runnable
{
  private String name;
  private int delay;
  private int points = 0;  // Laeuft von 0 bis 100
  private int progress;
  static int wins = 0;    // Zaehlt die einzelnen Laeufe bis 100

  public MyThread(String inName, int inDelay, ThreadInfoPanel inIPanel, ThreadProgressPanel inPPanel)
  {
    this.name = inName;
    this.delay = inDelay;
    inIPanel = inIPanel;
    inPPanel = inPPanel;
  }

public void run()
  {
    try
    {
      for (;;) // absichtliche Endlosschleife :)
      {
	    points ++;
	    final int j = points;
	    //pbFortschritt.setValue(points);
	    
	    
	    // Konstante in der Hauptklasse abfragen
	    if (points == Aufgabe4.WINSCORE)
	    {
	      wins ++;
                    
              // Ausgabe der Gewinne auf Kommandozeilenebene
              String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                      + " - " + wins + " Mal erreicht.";
	      System.out.println(s);
	      points = 0;
	    }
        
        // Thread legt sich fuer seine Verzoegerungsdauer schlafen
        Thread.sleep(delay);
      }
    }
    catch (InterruptedException e) { return; }
  }
}

_


----------



## Timmah (17. Jun 2006)

Also was war jetzt genau das weitere Problem?

Ändern den Konstruktor entsprechend ab, und übergib doch ein Limit im Konstruktor, statt für alle WINSCORE zu benutzen.


----------



## mike66 (22. Jun 2006)

Hi Timmah,

bin inzwischen ein gutes Stück weiter, das Problem sind jetzt noch die richtigen Parameter für:

MyFrame.java / Zeile 51
- die Parameter vom threadArray_ für ThreadInfoPanelArray und ThreadProgressPanelArray
stimmen nicht...

MyThread.java / Zeile 17 - 25
- ebenfalls die Parameter und der Aufruf innerhalb des Konstruktors von public MyThread(...)

Wobei MyThread die zwei Parameter für ThreadInfoPanel und ThreadProgressPanelArray benötigt,
damit er diese aktualisieren kann. Diese sollten dann jedoch keine int-Variablen mehr sein!?

Bei MyFrame bin ich mir ebenfalls nicht sicher welches die richtigen Parameter sein sollten, aber
wenn in MyThread neue Parameter gestzt werden müssen, müsste das im threadArray von
MyFrame wohl auch sein... zumindest verlangt das Eclipse !?  

Wenn hier dann die "Kommunikation" zwischen "MyFrame.java" und "MyThread.java" stimmt,
sollte das Programm zumindest mal vernünftig laufen. Dann fehlen "nur" noch die entsprechenden
set() und get()Methoden damit die Threads im Swingfenster angezeigt werden...

Vielen Dank

Mike66 






		Code:In die Zwischenablage kopieren


import java.awt.BorderLayout;import javax.swing.*;

import java.awt.Component;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class MyFrame extends JFrame implements ActionListener
{
	  //private JButton exitButton;
	  public JLabel inIPanel;
	  public JProgressBar inPPanel;
	  public JButton btEnde;
	  public int MyThread;
	  public JButton exitButton;
	  	  
	  
	  public MyFrame(int[] delay){
		setTitle("Threads");
		setSize(800, 500);
		exitButton = new JButton("Beenden");
				
		Container inhalt = getContentPane();
		inhalt.setLayout(new GridLayout(7, 1));

		ThreadInfoPanel[] ThreadInfoPanelArray = new ThreadInfoPanel[3];
		ThreadProgressPanel[] ThreadProgressPanelArray = new ThreadProgressPanel[3];
		for (int i=0; i<3; i++)
			{
			    ThreadInfoPanelArray[i] = new ThreadInfoPanel();
			    inhalt.add(ThreadInfoPanelArray[i]);                
			    ThreadProgressPanelArray[i] = new ThreadProgressPanel();
			    inhalt.add(ThreadProgressPanelArray[i]);
			}
		
		// Parameter  ThreadInfoPanelArray[i], ThreadProgressPanelArray[i] ???
		Thread[] threadArray = new Thread[3];
			for (int i=0; i<3; i++)
			{
				threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], ThreadInfoPanelArray[i], ThreadProgressPanelArray[i]));
				threadArray[i].start();
				System.out.println(threadArray[i]);
				System.out.println(delay[i]);
				
			}		
	  }
	  // ActionEvent
	  public void actionPerformed(ActionEvent event){
		// beendenButton Ereignis
		Object source = event.getSource();
		if (source == exitButton) System.exit(0);
		if (source == (btEnde)) System.exit(0);
	  }
}




		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;

public class MyThread extends Object implements Runnable
{
  private String name;
  private int delay;
  private int points = 0;  // Laeuft von 0 bis 100
  private int progress;
  static int wins = 0;    // Zaehlt die einzelnen Laeufe bis 100
  public ThreadInfoPanel infoPanel;
  public ThreadProgressPanel progressPanel;
  
  public MyThread(String inName, int inDelay, ThreadInfoPanel inIPanel, ThreadProgressPanel inPPanel)
  {
	this.name = inName;
	this.delay = inDelay;
	this.infoPanel = inIPanel;
	this.progressPanel = inPPanel;
	String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE + " noch nie erreicht."; 
	//infoPanel.setInfo(s);
  }


public void run()
  {
    try
    {
      for (;;) // absichtliche Endlosschleife :)
      {
	    points ++;
	    System.out.println(points);
	    // pPanel.setValue(points);
	    //infoPanel.setInfo(s);
	    //progressPanel.setProgress(points);
	    // Konstante in der Hauptklasse abfragen
	    if (points == Aufgabe4.WINSCORE)
	    {
	      wins ++;
                    
              // Ausgabe der Gewinne auf Kommandozeilenebene
              String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                      + " - " + wins + " Mal erreicht.";
	      System.out.println(s);
	      System.out.println(name + points);
	      points = 0;
	    }
        
        // Thread legt sich fuer seine Verzoegerungsdauer schlafen
        Thread.sleep(delay);
      }
    }
    catch (InterruptedException e) { return; }
  }

}




		Code:In die Zwischenablage kopieren


import java.awt.Container;
import javax.swing.*;
import java.awt.*; 
import java.awt.event.*;
/*
Erfuellt folgende Anforderungen:
- erwartet beim Programmstart 3 Parameter
- Pruefung, ob drei Befehlszeilen-Parameter eingegeben wurden
- Pruefung, ob drei ganze (Integer) Zahlen eingegeben wurden
  Im Fehlerfall wird ein Dialogfeld mit entsprechender Nachricht
  dargestellt und das Programm beendet
- Ausgabe der drei Zahlen in einem Dialogfeld
- Instanziierung und Starten der drei Threads
*/

public class Aufgabe4 extends Object
{
  public final static int WINSCORE = 10; // Highscore
  

  public static void main(String[] args)
  {
    int[] params = new int[3]; // Array fuer die drei int Parameter
  
    // Pruefen, ob genau drei Parameter eingegeben wurden
    if (args.length != 3)
    {
      String s = "Bitte geben Sie drei ganze Zahlen als Parameter an." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Pruefen, ob die drei Strings Integers sind
    try
    {
      for (int i = 0; i < 3; i++)
      {
        params[i] = Integer.parseInt(args[i]);
      }
    }
    catch (NumberFormatException e)
    {
      String s = "Mindestens einer der angegebenen Parameter ist keine ganze Zahl." +
                 "\nNach dem Drücken von OK wird das Programm beendet!";
      JOptionPane.showMessageDialog(null, s, "Fehler!", JOptionPane.ERROR_MESSAGE);
      System.exit(0);
    }
	
    // Alles in Ordnung -> Ausgabe der Parameter
    String s = "Die eingegebenen Werte sind:\n" + params[0] + ", " + params[1] + " und " + params[2];
    JOptionPane.showMessageDialog(null, s, "Information", JOptionPane.INFORMATION_MESSAGE);

    // Aufrufen des Konstruktors zur Gernerierung der Threads
    // Grund: in einer statischen Methode wie z.B. main kann man
    // nur statische Objekte und Variablen verwenden.
    new Aufgabe4(params);
  }
  

  public Aufgabe4(int[] delay) 
  {
	// Erstellung des Fensters zur Anzeige der Threads
    MyFrame frame = new MyFrame(delay);
    frame.setVisible(true);
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;

import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JPanel;

class ThreadProgressPanel extends JPanel
{
	
  private int i = 50;
	
  // Enthaelt ProgressBar für topThread, middleThread, bottomThread
  public ThreadProgressPanel()
  {
	JProgressBar inPPanel = new JProgressBar(0, 100);
	inPPanel.setStringPainted(true);
	setLayout(new FlowLayout(FlowLayout.CENTER));
    // add(inPPanel);
    // inPPanel.setValue(i);
  }
}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;

import javax.swing.AbstractButton;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;

class ThreadInfoPanel extends JPanel
{
  // JLabel jlInfo gibt Info ueber: name, delay, points, WINSCORE
  public ThreadInfoPanel()
  {
	JLabel inIPanel = new JLabel();
	setLayout(new FlowLayout(FlowLayout.LEFT));
    add(inIPanel);
    inIPanel.setText("Count: ");
  }
  
  /*
  public void setInfo(String s)
  {
	lblInfo.setText(s); // wobei lblInfo ein JLabel ist
  }
  */

}




		Code:In die Zwischenablage kopieren


import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JPanel;

class ButtonPanel extends JPanel
{
  // Enthaelt die Schaltflaeche "Beenden" in einem FlowLayout
	public ButtonPanel(JButton btEnde)
	{
		setLayout(new FlowLayout(FlowLayout.RIGHT));
	    add(btEnde);
	}
}

_


----------



## Timmah (23. Jun 2006)

Hi,

ich hatte schon ein Paar Posts vorher geschrieben, dass du das hier

```
threadArray[i] = new Thread(new MyThread("Thread " + (i + 1), delay[i], ThreadInfoPanelArray[i], ThreadProgressPanelArray[i]));
```

abändern musst, und zwar in das:


```
threadArray[i] = new MyThread("Thread " + (i + 1), delay[i], ThreadInfoPanelArray[i], ThreadProgressPanelArray[i]);
```

Außerdem änderst du das hier
	
	
	
	





```
public class MyThread extends Object implements Runnable
{
```

in


```
public class MyThread extends Thread
{
```

Falls es noch Fehler geben sollte, poste bitte mal den StackTrace, also das, was Eclipse dir in die Konsole als Fehler wirft.

Gruß
Timmah

EDIT: Ich habe mir deinen Code eben mal innen Workspace gezogen (das, was ich oben geschrieben habe, ist ja dasselbe, was du gemacht hast, nur etwas anders, sry :?   ).
Ich schaue mal genauer über den Code...


----------



## Timmah (23. Jun 2006)

```
import java.awt.Container;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class MyThread extends Thread
{
  private String name;
  private int delay;
  private int points = 0;  // Laeuft von 0 bis 100
  private int progress;
  static int wins = 0;    // Zaehlt die einzelnen Laeufe bis 100
  public ThreadInfoPanel infoPanel;
  public ThreadProgressPanel progressPanel;
 
  public MyThread(String inName, int inDelay, ThreadInfoPanel inIPanel, ThreadProgressPanel inPPanel)
  {
   this.name = inName;
   this.delay = inDelay;
   this.infoPanel = inIPanel;
   this.progressPanel = inPPanel;
   String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE + " noch nie erreicht.";
   //infoPanel.setInfo(s);
  }


public void run()
  {
    try
    {
      for (;;) // absichtliche Endlosschleife :)
      {
       points ++;
       System.out.println(points);
       // pPanel.setValue(points);
       //infoPanel.setInfo(s);
       //progressPanel.setProgress(points);
       // Konstante in der Hauptklasse abfragen
       if (points == Aufgabe4.WINSCORE)
       {
         wins ++;
                   
              // Ausgabe der Gewinne auf Kommandozeilenebene
              String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                      + " - " + wins + " Mal erreicht.";
         System.out.println(s);
         System.out.println(name + points);
         points = 0;
       }
       progressPanel.getInPPanel().setValue(wins);
        // Thread legt sich fuer seine Verzoegerungsdauer schlafen
        Thread.sleep(delay);
      }
    }
    catch (InterruptedException e) { return; }
  }

}
```




```
import java.awt.FlowLayout;

import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JPanel;

class ThreadProgressPanel extends JPanel
{
   
  private int i = 50;
  JProgressBar inPPanel;
   
  // Enthaelt ProgressBar für topThread, middleThread, bottomThread
  public ThreadProgressPanel()
  {
   inPPanel = new JProgressBar(0, 100);
   inPPanel.setStringPainted(true);
   setLayout(new FlowLayout(FlowLayout.CENTER));
   add(inPPanel);

  }

public JProgressBar getInPPanel()
{
	return inPPanel;
}

public void setInPPanel(JProgressBar inPPanel)
{
	this.inPPanel = inPPanel;
}
}
```

In den beiden Klassen habe ich kleine Änderungen gemacht, so dass es nun auf der Gui angezeigt wird. Insofern stimmt deine Kommunikation doch. Gib nur noch dann entsprechend die Zeiten aus, die der Thread braucht, um auf 100 zu kommen, und setze dann wieder den Balken auf 0%.


----------



## mike66 (23. Jun 2006)

Hi,

das Programm läuft jetzt... bis auf das ImageIcon welches im Swingfenster angezeigt werden
soll sobald der jeweilige Thread aktiv ist...

D.h. die Methode in ThreadInfoPanel.java

   public void setIsRunning(boolean flag) {
      if (flag) {
         iconLabel.setIcon(GREEN_LIGHT);
      } else {
         iconLabel.setIcon(null);
      }
     iconLabel.validate();
   }

und der jeweilige Aufruf in MyThread.java

infoPanel.setIsRunning(true);
infoPanel.setIsRunning(false);

... führt nicht zum gewünschten Ergebnis 

Hat jemand ne Idee???

Danke Mike66


```
import java.awt.Container;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;


public class Aufgabe4
      extends Object
{

   public final static int WINSCORE = 100; // Highscore


   public static void main( String[] args ) {
      int[] params = new int[3]; // Array fuer die drei int Parameter

      // Pruefen, ob genau drei Parameter eingegeben wurden
      if ( args.length != 3 ) {
         String s = "Bitte geben Sie drei ganze Zahlen als Parameter an." +
               "\nNach dem Druecken von OK wird das Programm beendet!";
         JOptionPane.showMessageDialog( null, s, "Fehler!", JOptionPane.ERROR_MESSAGE );
         System.exit( 0 );
      }

      // Pruefen, ob die drei Strings Integers sind
      try {
         for ( int i = 0; i < 3; i++ ) {
            params[i] = Integer.parseInt( args[i] );
         }
      }
      catch ( NumberFormatException e ) {
         String s = "Mindestens einer der angegebenen Parameter ist keine ganze Zahl." +
               "\nNach dem Druecken von OK wird das Programm beendet!";
         JOptionPane.showMessageDialog( null, s, "Fehler!", JOptionPane.ERROR_MESSAGE );
         System.exit( 0 );
      }

      // Alles in Ordnung -> Ausgabe der Parameter
      String s = "Die eingegebenen Werte sind:\n" + params[0] + ", " + params[1] + " und " + params[2];
      JOptionPane.showMessageDialog( null, s, "Information", JOptionPane.INFORMATION_MESSAGE );

      // Aufrufen des Konstruktors zur Gernerierung der Threads
      // Grund: in einer statischen Methode wie z.B. main kann man
      // nur statische Objekte und Variablen verwenden.
      new Aufgabe4( params );
   }


   public Aufgabe4( int[] delay ) {
      // Erstellung des Fensters zur Anzeige der Threads
      MyFrame frame = new MyFrame( delay );
      frame.setVisible( true );
   }
}
```


```
import java.awt.BorderLayout;
import javax.swing.*;

import java.awt.Component;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class MyFrame
      extends JFrame
      implements ActionListener
{

   private JLabel inIPanel;

   private JProgressBar inPPanel;

   private JButton btEnde;

   private ThreadGroup threadGroup;

   private JButton exitButton;


   public MyFrame( int[] delay ) {
      setTitle( "Threads" );
      setSize( 800, 500 );
      exitButton = new JButton( "Beenden" );
      exitButton.addActionListener( this );
      btEnde = new JButton( "Threads beenden" );
      btEnde.addActionListener( this );

      Container inhalt = getContentPane();
      inhalt.setLayout( new GridLayout( 7, 1 ) );

      ThreadInfoPanel[] ThreadInfoPanelArray = new ThreadInfoPanel[3];
      ThreadProgressPanel[] ThreadProgressPanelArray = new ThreadProgressPanel[3];
      for ( int i = 0; i < 3; i++ ) {
         ThreadInfoPanelArray[i] = new ThreadInfoPanel();
         inhalt.add( ThreadInfoPanelArray[i] );
         ThreadProgressPanelArray[i] = new ThreadProgressPanel();
         inhalt.add( ThreadProgressPanelArray[i] );
      }

      // Parameter  ThreadInfoPanelArray[i], ThreadProgressPanelArray[i] ???
      threadGroup = new ThreadGroup( "Aufgabe4" );
      Thread[] threadArray = new Thread[3];
      for ( int i = 0; i < 3; i++ ) {
         threadArray[i] = new Thread( threadGroup,
               new MyThread( "Thread " + ( i + 1 ), delay[i], ThreadInfoPanelArray[i], ThreadProgressPanelArray[i] ) );
         threadArray[i].start();
      }
      // create Panel with new FlowLayout
      JPanel buttonPanel = new JPanel();
      buttonPanel.setLayout( new FlowLayout( FlowLayout.RIGHT ) );
      buttonPanel.add( btEnde );
      buttonPanel.add( exitButton );
      inhalt.add( buttonPanel );
   }

   // ActionEvent
   public void actionPerformed( ActionEvent event ) {
      // beendenButton Ereignis
      Object source = event.getSource();
      if ( source == exitButton ) System.exit( 0 );
      if ( source == ( btEnde ) ) {
         // interupt all threads
         threadGroup.interrupt();
      }
   }
}
```


```
import java.awt.Container;
import javax.swing.*;

import java.awt.*;
import java.awt.event.*;

public class MyThread
      extends Object
      implements Runnable
{

   private String name;

   private long delay;

   private int points = 0;  // Laeuft von 0 bis 100

   private int progress;

   private int wins = 0;    // Zaehlt die einzelnen Laeufe bis 100

   public ThreadInfoPanel infoPanel;

   public ThreadProgressPanel progressPanel;

   public MyThread( String inName, int inDelay, ThreadInfoPanel inIPanel, ThreadProgressPanel inPPanel ) {
      this.name = inName;
      this.delay = inDelay;
      this.infoPanel = inIPanel;
      this.progressPanel = inPPanel;
      String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE + " noch nie erreicht.";
   }


   public void run() {
      try {
         for ( ; ; ) // absichtliche Endlosschleife :)
         {
            infoPanel.setIsRunning( true );
            points ++;
            System.out.println( points );
            System.out.println( name + " ist aktiv!!!" );

            // Name des jeweiligen Threads
            infoPanel.setName( name );

            // Verzoegerung des jeweiligen Threads
            infoPanel.setDelay( new Long( delay ).toString() );

            // wins des jeweiligen Threads
            // infoPanel.setWinInfo(new Integer(wins).toString());

            infoPanel.setWin( new Integer( wins ).toString() );

            // Progress des jeweiligen Threads
            progressPanel.setProgress( points );
            Thread.sleep( delay + (long)(0.1f * ( float )delay) );

            // Konstante in der Hauptklasse abfragen
            if ( points == Aufgabe4.WINSCORE ) {
               wins ++;

               // Ausgabe der Gewinne auf Kommandozeilenebene
               String s = name + " mit " + delay + " ms Verzoegerung hat " + Aufgabe4.WINSCORE
                     + " - " + wins + " Mal erreicht.";
               System.out.println( s );
               infoPanel.setWin( new Integer( wins ).toString() );

               points = 0;
            }

            // Thread legt sich fuer seine Verzoegerungsdauer schlafen
            infoPanel.setIsRunning( false );
            Thread.sleep( delay );
            System.out.println( name + " ist nicht aktiv!!!" );
         }
      }
      catch ( InterruptedException e ) {
         return;
      }
   }

}
```


```
import java.awt.*;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.*;

class ThreadInfoPanel
      extends JPanel
{
   private static final ImageIcon GREEN_LIGHT = new ImageIcon( "green.gif" );
   private JLabel nameLabel;
   private JLabel delayLabel;
   private JLabel pointsLabel;
   private JLabel inIPanel;
   private JLabel iconLabel;
   private JPanel iconPanel;

   // JLabel jlInfo gibt Info ueber: name, delay, points, WINSCORE
   public ThreadInfoPanel() {
      super();
      setLayout(new FlowLayout(FlowLayout.LEFT));
      nameLabel = new JLabel( " " );
      add( nameLabel );
      delayLabel = new JLabel( " " );
      add( delayLabel );
      pointsLabel = new JLabel( "Points: " );
      add( pointsLabel );
      inIPanel = new JLabel();
      add( inIPanel );
      inIPanel.setText( " " );
      
      JPanel iconPanel = new JPanel( new BorderLayout( ) );
      add( iconPanel );
      
      iconLabel = new JLabel(  );
      iconPanel.add( iconLabel, BorderLayout.CENTER );
   }

   // Name des jeweiligen Threads
   public void setName( String s ) {
      nameLabel.setText( s );
   }

   // Delay des jeweiligen Threads
   public void setDelay( String s ) {
      delayLabel.setText( "mit " + s + " ms Verzoegerung" );
   }

   // wins des jeweiligen Threads
   public void setWinInfo( String s ) {
      pointsLabel.setText( "hat zum " + s + ".Mal " + Aufgabe4.WINSCORE + " erreicht." );
   }

   //Progress des jeweiligen Threads
   public void setWin( String s ) {
      inIPanel.setText( s );
   }

   public void setIsRunning( boolean flag ) {
      if ( flag ) {
         iconLabel.setIcon( GREEN_LIGHT );
      } else {
         iconLabel.setIcon( null );
      }
     iconLabel.validate();
   }
}
```


```
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JPanel;

class ButtonPanel
      extends JPanel
{

   // Enthaelt die Schaltflaeche "Beenden" in einem FlowLayout
   public ButtonPanel( JButton btEnde ) {
      setLayout( new FlowLayout( FlowLayout.RIGHT ) );
      add( btEnde );
   }
}
```


```
import java.awt.FlowLayout;

import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JPanel;

class ThreadProgressPanel
      extends JPanel
{

   private int i = 50;

   private JProgressBar inPPanel;

   // Enthaelt ProgressBar fï¿½r topThread, middleThread, bottomThread
   public ThreadProgressPanel() {
      inPPanel = new JProgressBar( 0, Aufgabe4.WINSCORE );
      inPPanel.setStringPainted( true );
      setLayout( new FlowLayout( FlowLayout.CENTER ) );
      add( inPPanel );
      inPPanel.setValue( i );
   }

   //Progress des jeweiligen Threads
   public void setProgress( int newProgress ) {
      inPPanel.setValue( newProgress );
   }
}
```


----------

