ThreadGroup-Problem

[Reality]

Hi,
je mehr ich das Buch kenne, desto mehr lerne ich es hassen!

ThreadGroup richtet eine Thread-Gruppe ein. Die Methode besitzt zwei Konstruktoren:

ThreadGroup(String Gruppte)
ThreadGroup(ThreadGroup übergeordObj, String Gruppe)

In beiden Fällen gibt Gruppe den Namen der Gruppe an. Die erste Version richtet eine neue Gruppe ein, der der aktuelle Thread übergeordnet ist. In der zweiten Variante wird das übergeordnete Objekt mit übergeordObj angegeben.

Im Code ruft er glaube ich den zweiten Konstruktor auf. Sagt mir bitte bescheid, wenn ich mich irre:

super(tgOb, threadname);

Hier der gesamte Code:

class NewThread extends Thread
{
boolean suspendFlag;

  NewThread(String threadname, ThreadGroup tgOb){
  super(tgOb, threadname);
  System.out.println("Neuer Thread: "+ this);
  suspendFlag= false;
  start(); //Thread-Start ;-)
  }

  //Einstiegspunkt für den Thread ;-) :-D
  public void run()
  {
    try{
      for(int i=5; i>0; i--){
        System.out.println(getName()+ ": "+i);
        Thread.sleep(1000);
        synchronized(this){
          while(suspendFlag)
            wait();
        }
      }
    }catch(Exception e){
      System.out.println(getName()+" verlassen.");
    }
  }

  void mysuspend()
  {
  suspendFlag= true;
  }

  synchronized void myresume()
  {
  suspendFlag= false;
  notify();
  }
}

class ThreadGroupDemo {
  public static void main(String[] args) {
    ThreadGroup groupA= new ThreadGroup("Gruppe A");
    ThreadGroup groupB= new ThreadGroup("Gruppe B");
    
    NewThread ob1 = new NewThread("Eins", groupA);
    NewThread ob2 = new NewThread("Zwei", groupA);
    NewThread ob3 = new NewThread("Drei", groupB);
    NewThread ob4 = new NewThread("Vier", groupB);
    
    System.out.println("\nAusgabe von list():");
    groupA.list();
    groupB.list();
    
    System.out.println();
    
    System.out.println("Gruppe A angehalten");
    Thread tga[] = new Thread[groupA.activeCount()];
    for(int i=0; i<tga.length; i++)
      ((NewThread)tga[i]).mysuspend(); //JedenThread unterbrechen
    
    try{
      Thread.sleep(4000);
    }catch(InterruptedException e){
      System.out.println("Haupt-Thread unterbrochen!");
    }
    
    System.out.println("Wiederaufnahme von Gruppe A");
    for(int i=0; i<tga.length; i++)
      ((NewThread)tga[i]).myresume();  //Threads wieder aufnehmen
    
    //Auf das Ende der Threads abwarten
    try{
      System.out.println("Ende der Threads abwarten");
      ob1.join();
      ob2.join();
      ob3.join();
      ob4.join();
    }catch(Exception e){
      System.out.println("Ausnahme im Haupt-Thread");
    }
  System.out.println("Haupt-Thread verlassen.");
  }
}

Was bei mir rauskommt, sind zwei Exceptions!

java.lang.NullPointerException

at ThreadGroupDemo.main(ThreadGroupDemo.java:62)

Neuer Thread: Thread[Eins,5,Gruppe A]

Neuer Thread: Thread[Zwei,5,Gruppe A]

Neuer Thread: Thread[Drei,5,Gruppe B]

Neuer Thread: Thread[Vier,5,Gruppe B]


Ausgabe von list():

java.lang.ThreadGroup[name=Gruppe A,maxpri=10]

Thread[Eins,5,Gruppe A]

Thread[Zwei,5,Gruppe A]

java.lang.ThreadGroup[name=Gruppe B,maxpri=10]

Thread[Drei,5,Gruppe B]

Thread[Vier,5,Gruppe B]



Gruppe A angehalten

Eins: 5

Zwei: 5

Drei: 5

Vier: 5

Eins: 4

Zwei: 4

Drei: 4

Vier: 4

Eins: 3

Zwei: 3

Drei: 3

Vier: 3

Eins: 2

Zwei: 2

Drei: 2

Vier: 2

Eins: 1

Zwei: 1

Drei: 1

Vier: 1

Exception in thread "main"

Wenn ich super(tgOb, threadname); mit new ThreadGroup(tgOb, threadname); ersetze, kommt keine Exception, aber es wird dann auch nicht alles vollständig ausgegeben!

Neuer Thread: Thread[Thread-0,5,main]

Neuer Thread: Thread[Thread-1,5,main]

Neuer Thread: Thread[Thread-2,5,main]

Neuer Thread: Thread[Thread-3,5,main]

Thread-0: 5

Thread-1: 5

Thread-2: 5


Ausgabe von list():

java.lang.ThreadGroup[name=Gruppe A,maxpri=10]

java.lang.ThreadGroup[name=Eins,maxpri=10]

java.lang.ThreadGroup[name=Zwei,maxpri=10]

java.lang.ThreadGroup[name=Gruppe B,maxpri=10]

java.lang.ThreadGroup[name=Drei,maxpri=10]

java.lang.ThreadGroup[name=Vier,maxpri=10]



Gruppe A angehalten

Thread-3: 5

Thread-0: 4

Thread-1: 4

Thread-2: 4

Thread-3: 4

Thread-0: 3

Thread-1: 3

Thread-2: 3

Thread-3: 3

Thread-0: 2

Thread-1: 2

Thread-2: 2

Thread-3: 2

Thread-0: 1

Thread-1: 1

Thread-2: 1

Wiederaufnahme von Gruppe A

Ende der Threads abwarten

Thread-3: 1

Haupt-Thread verlassen.

Ich hoffe ihr könnt mir helfen!

Liebe Grüße
Reality

 

[Beni]

Hier ist ja noch gar nichs im Array:

    Thread tga[] = new Thread[groupA.activeCount()];
    for(int i=0; i<tga.length; i++)
      ((NewThread)tga[i]).mysuspend(); //JedenThread unterbrechen

Denn muss man zuerst füllen, versuch mal:

    Thread tga[] = new Thread[groupA.activeCount()];
    groupA.enumerate( tga );
    for(int i=0; i<tga.length; i++)
      ((NewThread)tga[i]).mysuspend(); //JedenThread unterbrechen

mfg Beni

 

[Reality]

Danke, stimmt! Den Code habe ich übersehen.

Liebe Grüße
Reality

 

[Reality]

Kleine Frage noch:
Welcher Konstruktor wird eigentlich mit super(tgOb, threadname); aufgerufen?

Liebe Grüße
Reality