Thread beenden

Schlagdraufunschluss_124 · 30. Jan 2018

Ich bin schon seit einiger Zeit wieder an einem Problem:
Ich will in einer PlayeranimationKLasse eine Animation in einem Thread ausführen lassen.Das Thread wird von einer KeyHandlerKlasse aufgerufen.
-> KeyPressed = start();
...Animieren...
-> KeyReleased = stop();
Allerdings bekomme ich es nicht hin, den Thread, sobald er einmal in der WhileAnimierenSchlaufe ist per Interrupt() zu beenden und die Animation läuft bis zum Schluss zu ende, obwohl ich eben schon vorher die Taste losgelassen habe.

Klasse KeyHandler

Java:

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class KeyHandler implements KeyListener {

    private Data data;
    private PlayerAnimation plAnimation;
    private int x = 0;
    private int y = 0;

    private int animationDirec = 0;
    private boolean inThread = false;

    public KeyHandler(Data data, Spiel spiel) {
        this.data = data;
        PlayerAnimation plAnimation = new PlayerAnimation(spiel, this);
        this.plAnimation = plAnimation;

    }

    @Override
    public void keyPressed(KeyEvent e) {

        // UP - Case 2
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            y -= 2;
            data.setAdd_Y(y);

            animationDirec = 2;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                new Thread(plAnimation).start();
            }
        }

        // DOWN - Case 1
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            y += 2;
            data.setAdd_Y(y);

            animationDirec = 1;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;

                new Thread(plAnimation).start();

            }
        }
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            x -= 2;
            data.setAdd_X(x);

            animationDirec = 3;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                new Thread(plAnimation).start();
            }

        }
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            x += 2;
            data.setAdd_X(x);

            animationDirec = 4;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                new Thread(plAnimation).start();
            }

        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            for (int i = 0; i <= 1; i++) {
                plAnimation.interrupt();
            }
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    public boolean getInThread() {
        return inThread;
    }

    public void setInThread(boolean inThread) {
        this.inThread = inThread;

    }

}

Klasse Animation

Java:

import java.util.Timer;
import java.util.TimerTask;

public class PlayerAnimation extends Thread {

    private KeyHandler keyHandler;
    private Spiel spiel;
    private boolean inThread;
    private int animationDirec;
    private final long threadSleep = 90;

    public PlayerAnimation(Spiel spiel, KeyHandler keyHandler) {
        this.spiel = spiel;
        this.keyHandler = keyHandler;
    }

    @Override
    public void run() {
        switch (this.animationDirec) {
        case 1:
            try {
                while (keyHandler.getInThread() == true) {
                    spiel.curAnim = 1;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 2;
                    Thread.sleep(threadSleep);
                    spiel.curAnim =0;
                    Thread.sleep(threadSleep);
                    System.out.println("InTHread"+keyHandler.getInThread());
                    keyHandler.setInThread(false);
                  
                }
                break;
            } catch (InterruptedException e) {

                e.printStackTrace();

            }
        case 2:
            try {
                while (keyHandler.getInThread() == true ) {
                    spiel.curAnim = 3;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 4;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 5;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 6;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 7;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 8;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 9;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 10;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 11;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 12;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 13;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 14;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 3;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
                break;
            } catch (InterruptedException e) {
                interrupt();
                e.printStackTrace();

            }
        case 3:
            try {
                while (keyHandler.getInThread() == true) {

                    spiel.curAnim = 7;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 8;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 6;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }
        case 4:
            try {
                while (keyHandler.getInThread() == true) {

                    spiel.curAnim = 10;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 11;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 9;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }

       /* case 5:

            if (spiel.curAnim >= 0 && spiel.curAnim <= 2) {
                spiel.curAnim = 0;
            } else if (spiel.curAnim >= 3 && spiel.curAnim <= 5) {
                spiel.curAnim = 3;
            } else if (spiel.curAnim >= 6 && spiel.curAnim <= 8) {
                spiel.curAnim = 6;
            } else if(spiel.curAnim >= 9 && spiel.curAnim <= 11){
                spiel.curAnim = 9;
            }*/

        }
    }

    // GETTER/SETTER

    public void setAnimationDirec(int animationDirec) {
        this.animationDirec = animationDirec;
    }

}

Wo liegt mein Fehler ?

AndyJ · 31. Jan 2018

Probier mal statt
new Thread(plAnimation).start(); // das erzeugt einen neuen Thread und du hast keinen Zeiger darauf.
das hier:
plAnimation.start(); // das ist vermutlich eher was du machen willst

Deine Klasse PlayerAnimation erweiter ja Thread, aber als argument verwendet ist es nur noch ein Runnable und dein call zu interrupt gehts ins leere, weil der eigentliche Thread anonym ist.

Cheers,
Andy

Schlagdraufunschluss_124 · 31. Jan 2018

Ok. Leider gibt die Konsole jetzt "java.lang.InterruptedException: sleep interrupted" aus.
Wenn ich erneut in die Animation gehen will, dann funtioniert sie nicht mehr und das Programm bleibt beim zuletzt gerenderten BIld stehen.

AndyJ · 31. Jan 2018

Mein Rat in solchen Faellen ist es immer erst mal die Javadocs zu lesen. In der Docu fuer Thread.start steht unter anderem: "It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution."
Das heisst, du musst erst eine neue Instanz erzeugen und diese dann starten.

Die Javadocs gibt's online ( https://docs.oracle.com/javase/8/docs/api/ ) oder auch hier als Windows help file: https://javadoc.allimant.org/ (fuer Linux gibt's auch einen Viewer fuer das Format).

Have fun,
Andy

Thallius · 1. Feb 2018

Warum überhaupt mit der dicken Keule?

Mach doch in deinen Animations-Thread eine Methode stop() und dort setzt du dann eine Variable stopped = true. Innerhalb der Schleife fragst du ab ob stopped gesetzt ist und beendest dann die Schleife und den Thread ganz sauber.

Gruß

Claus

Schlagdraufunschluss_124 · 1. Feb 2018

Meinst du etwa so ?

Java:

public class PlayerAnim extends Thread{

run() {
while(isRunning){
//Animieren
}
}
stop(){
isRunning = false;
}
}

So funktionierts nämlich leider nicht :/ -> Die Animation geht trotzdem erstmal zuEnde.

Java:

import java.util.Timer;
import java.util.TimerTask;

public class PlayerAnimation extends Thread {

    private KeyHandler keyHandler;
    private Spiel spiel;
    boolean inThread;
    private int animationDirec;
    private final long threadSleep = 200;

    public PlayerAnimation(Spiel spiel, KeyHandler keyHandler) {
        this.spiel = spiel;
        this.keyHandler = keyHandler;
    }

    @Override
    public void run() {
        switch (this.animationDirec) {
        case 1:
            try {
                while (getInThread()) {
                    spiel.curAnim = 1;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 2;
                    Thread.sleep(threadSleep);
                    spiel.curAnim =0;
                    Thread.sleep(threadSleep);
                    //System.out.println("InTHread"+inThread);
                
                }
            
            } catch (InterruptedException e) {
                endThread();
                e.printStackTrace();

            }
        case 2:
            try {
                while (getInThread()) {
                    spiel.curAnim = 3;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 4;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 5;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 6;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 7;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 8;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 9;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 10;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 11;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 12;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 13;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 14;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 3;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
            
            } catch (InterruptedException e) {
                endThread();
                e.printStackTrace();
            
            

            }
        case 3:
            try {
                while (keyHandler.getInThread() == true) {

                    spiel.curAnim = 7;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 8;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 6;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }
        case 4:
            try {
                while (keyHandler.getInThread() == true) {

                    spiel.curAnim = 10;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 11;
                    Thread.sleep(threadSleep);
                    spiel.curAnim = 9;
                    Thread.sleep(threadSleep);
                    keyHandler.setInThread(false);
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        case 5:

            if (spiel.curAnim >= 0 && spiel.curAnim <= 2) {
                spiel.curAnim = 0;
            } else if (spiel.curAnim >= 3 && spiel.curAnim <= 5) {
                spiel.curAnim = 3;
            } else if (spiel.curAnim >= 6 && spiel.curAnim <= 8) {
                spiel.curAnim = 6;
            } else if(spiel.curAnim >= 9 && spiel.curAnim <= 11){
                spiel.curAnim = 9;
            }

        }
    
    }
    public void endThread(){
        setInThread(false);
    }
    public void startThread(){
        setInThread(true);
        new Thread(this).start();
    }
 
 
 


    // GETTER/SETTER

    public void setAnimationDirec(int animationDirec) {
        this.animationDirec = animationDirec;
    }
    public boolean getInThread(){
        return inThread;
    }
    public void setInThread(boolean inThread){
        this.inThread = inThread;
        System.out.println("INTHREAD "+getInThread());
    }

 

}

KEYHANDLER (Hab des mit dem Start auch grad gelesen

)

Java:

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class KeyHandler implements KeyListener {

    private Data data;
    private PlayerAnimation plAnimation;
    private int x = 0;
    private int y = 0;

    private int animationDirec = 0;
    private boolean inThread = false;

    public KeyHandler(Data data, Spiel spiel) {
        this.data = data;
        PlayerAnimation plAnimation = new PlayerAnimation(spiel, this);
        this.plAnimation = plAnimation;

    }

    @Override
    public void keyPressed(KeyEvent e) {

        // UP - Case 2
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            y -= 2;
            data.setAdd_Y(y);

            animationDirec = 2;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                plAnimation.startThread();
                System.out.println("StartenUP");
            }
         
         
        }

        // DOWN - Case 1
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            y += 2;
            data.setAdd_Y(y);

            animationDirec = 1;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                plAnimation.startThread();
                System.out.println("StartenDown");

            }
        }
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            x -= 2;
            data.setAdd_X(x);

            animationDirec = 3;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                new Thread(plAnimation).start();
            }

        }
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            x += 2;
            data.setAdd_X(x);

            animationDirec = 4;
            plAnimation.setAnimationDirec(animationDirec);

            if (inThread == false) {
                inThread = true;
                new Thread(plAnimation).start();
            }

        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            plAnimation.endThread();
            inThread = false;
            System.out.println("BeendenUP");
         
         
        }
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            plAnimation.endThread();
            inThread = false;
            System.out.println("BeendenDOWN");
         
        }
     
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    public boolean getInThread() {
        return inThread;
    }

    public void setInThread(boolean inThread) {
        this.inThread = inThread;

    }

}

AndyJ · 1. Feb 2018

Schlagdraufunschluss_124 hat gesagt.:
So funktionierts nämlich leider nicht :/ -> Die Animation geht trotzdem erstmal zuEnde.

Hi,

das Problem ist, dass dein Thread die Aenderung der Kontrollvariable nicht sieht, da diese ja auf dem Hauptthread gemacht wird:

private boolean inThread = false;

Das Keyword volatile wird vermutlich dieses Problem loesen:
private volatile boolean inThread = false;

Mehr darueber hier:
https://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html

Cheers,
Andy

Schlagdraufunschluss_124 · 2. Feb 2018

Mmmh... Ich denke, dass ich das Grundproblem gelöst haben sollte.
ABER:
Wenn ich irgendwie zu oft die Richtung des Spielers wechsle, animiert der Thread zwei Richtungen gleichzeitig, was ziemlich buggy aussieht

Java:

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class KeyHandler implements KeyListener {

    private Data data;
    private PlayerAnimation plAnimation;
    private PlayerPos plPos;
    private int x = 0;
    private int y = 0;

    private int animationDirec = 0;
    private volatile boolean inThread = false;

    public KeyHandler(Data data, Spiel spiel) {
        this.data = data;
        PlayerAnimation plAnimation = new PlayerAnimation(spiel, this);
        this.plAnimation = plAnimation;

        PlayerPos plPos = new PlayerPos(this);
        this.plPos = plPos;

    }

    @Override
    public void keyPressed(KeyEvent e) {

        // DOWN - Case 1
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {

            if (getInThread() == false) {
                setInThread(true);

                animationDirec = 1;

                plPos.setCurrentDirection(animationDirec);
                plPos.startThread();

                /*
                 * y += 2; data.setAdd_Y(y);
                 */
               
                plAnimation.setAnimationDirec(animationDirec);
                plAnimation.startThread();
               
                System.out.println("StarteDOWN"+ getInThread());

            }

        }

        // UP - Case 2
        if (e.getKeyCode() == KeyEvent.VK_UP) {
           
            if (getInThread() == false) {
                setInThread(true);

                animationDirec = 2;

                plPos.setCurrentDirection(animationDirec);
                plPos.startThread();

                /*
                 * y += 2; data.setAdd_Y(y);
                 */

                plAnimation.setAnimationDirec(animationDirec);
                plAnimation.startThread();
                System.out.println("StarteUP"+ getInThread());

            }

        }
        //LEFT - Case 3
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
           
            if (getInThread() == false) {
                setInThread(true);

                animationDirec = 3;

                plPos.setCurrentDirection(animationDirec);
                plPos.startThread();

                /*
                 * y += 2; data.setAdd_Y(y);
                 */

                plAnimation.setAnimationDirec(animationDirec);
                plAnimation.startThread();

            }

        }
        //RIGHT - Case 4
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
   
            if (getInThread() == false) {
                setInThread(true);

                animationDirec = 4;

                plPos.setCurrentDirection(animationDirec);
                plPos.startThread();

                /*
                 * y += 2; data.setAdd_Y(y);
                 */

                plAnimation.setAnimationDirec(animationDirec);
                plAnimation.startThread();

            }
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            plPos.endThread();
            plAnimation.endThread();
            setInThread (false);
            System.out.println("BeendenUP"+getInThread());

        }
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            plPos.endThread();
            plAnimation.endThread();
            setInThread (false);
            System.out.println("BeendenDOWN"+getInThread());

        }
        if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            plPos.endThread();
            plAnimation.endThread();
            setInThread (false);

        }
        if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            plPos.endThread();
            plAnimation.endThread();
            setInThread (false);

        }

    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    public boolean getInThread() {

        return inThread;
    }

    public void setInThread(boolean inThread) {
        this.inThread = inThread;

    }

    public void setPos_X(int x) {
        this.x = x;

    }

    public void setPos_Y(int y) {
        this.y = y;

    }

    public int getPos_X() {
        return x;
    }

    public int getPos_Y() {
        return y;
    }

}

Java:

import java.util.Timer;
import java.util.TimerTask;

public class PlayerAnimation extends Thread {

    private KeyHandler keyHandler;
    private Spiel spiel;
    private boolean inThread;
    private int animationDirec;
    private final long threadSleep = 90;

    public PlayerAnimation(Spiel spiel, KeyHandler keyHandler) {
        this.spiel = spiel;
        this.keyHandler = keyHandler;
    }

    @Override
    public void run() {
        switch (this.animationDirec) {

        // DOWN
        case 1:
            try {
                while (keyHandler.getInThread()) {
                    for (int i = 0; i < 3; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);

                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 0;
                            break;

                        }

                    }
                }

            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            break;

        // UP
        case 2:
            try {
                while (keyHandler.getInThread()) {
                    for (int i = 3; i < 14; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);

                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 3;
                            break;

                        }

                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            break;

        case 3:
            try {
                while (keyHandler.getInThread()) {
                    for (int i = 3; i < 14; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);

                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 3;
                            break;

                        }

                    }
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }
        case 4:
            try {
                while (keyHandler.getInThread()) {
                    for (int i = 3; i < 14; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);

                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 3;
                            break;

                        }

                    }
                }
            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public void endThread() {
        setInThread(false);
    }

    public void startThread() {
        setInThread(true);
        new Thread(this).start();
    }

   

    // GETTER/SETTER

    public void setAnimationDirec(int animationDirec) {
        this.animationDirec = animationDirec;
    }

    public boolean getInThread() {
        return inThread;
    }

    public void setInThread(boolean inThread) {
        this.inThread = inThread;
    }

}

Was geht nun schon wieder schief ??

Thallius · 2. Feb 2018

Also dein Konzept ist einfach Mist. Bei jeder Richtungsänderung den Thread killen und einen neuen starten ist ja vollkommen sinnfrei.

Auch hier würde ich einfach dem Thread mitteilen, das er halt die Richtung ändern muss indem ich eine Variable setze...

Schlagdraufunschluss_124 · 2. Feb 2018

Cool danke an euch alle !!!!

Es hat geklappt! Hat wohl wirklich an meinem Konzept und dem volatile gelegen...(der junge Padawan hat noch viel zu lernen

)

Hier UP (1) und DOWN (2) als BSP.

Java:

import java.util.Timer;
import java.util.TimerTask;

public class PlayerAnimation extends Thread {

    private KeyHandler keyHandler;
    private Spiel spiel;
    private boolean inThread;
    private volatile int animationDirec;
    private final long threadSleep = 90;

    public PlayerAnimation(Spiel spiel, KeyHandler keyHandler) {
        this.spiel = spiel;
        this.keyHandler = keyHandler;
        this.start();
    }

    @Override
    public void run() {
        while (true) {
            switch (this.animationDirec) {
            case 1:
                try {
                    for (int i = 0; i < 3; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);
                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 0;
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                break;

            case 2:
                try {

                    for (int i = 3; i < 14; i++) {
                        spiel.curAnim = i;
                        Thread.sleep(threadSleep);
                        if (keyHandler.getInThread() == false) {
                            spiel.curAnim = 3;
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                break;

            }
        }
    }

    public void endThread() {
        setInThread(false);
    }

    public void startThread(int animDirec) {
        setInThread(true);
        setAnimationDirec(animDirec);
    }

    // GETTER/SETTER

    public void setAnimationDirec(int animationDirec) {
        this.animationDirec = animationDirec;
    }

    public boolean getInThread() {
        return inThread;
    }

    public void setInThread(boolean inThread) {
        this.inThread = inThread;
    }

}

Unten steht halt noch bissle Quatsch...

	Titel	Forum	Antworten	Datum
U	Thread beenden	Allgemeine Java-Themen	3	3. Jun 2014
B	Erkennen, wann Prozess beendet ist, dann Thread beenden.	Allgemeine Java-Themen	6	20. Jan 2014
S	[THREADS] Thread sinnvoll beenden	Allgemeine Java-Themen	2	23. Feb 2011
O	Thread beenden egal welcher Zustand?	Allgemeine Java-Themen	8	14. Feb 2011
S	Thread beenden	Allgemeine Java-Themen	50	18. Jan 2011
G	Thread nach x Sekunden beenden ...	Allgemeine Java-Themen	8	13. Jul 2010
B	Thread beenden (von anderer Klasse)	Allgemeine Java-Themen	20	25. Mai 2010
S	Thread nach Timeout beenden	Allgemeine Java-Themen	2	22. Jul 2009
B	Thread soll anderen Thread beenden	Allgemeine Java-Themen	5	15. Mai 2009
O	Thread beenden (gnadenlos und ohne rücksicht auf Verluste) ?	Allgemeine Java-Themen	17	3. Jun 2008
S	Thread per GUI Beenden	Allgemeine Java-Themen	3	3. Mrz 2008
F	Thread beenden ?	Allgemeine Java-Themen	4	22. Nov 2007
J	Thread beenden und wieder starten?	Allgemeine Java-Themen	20	10. Okt 2007
R	Thread beenden und warten, bis er fertig ist	Allgemeine Java-Themen	4	11. Jul 2007
A	Wie kann man diesen thread beenden?	Allgemeine Java-Themen	17	30. Apr 2007
D	Thread & Process: Beenden einer Batch-Datei	Allgemeine Java-Themen	8	18. Apr 2007
G	Thread beenden	Allgemeine Java-Themen	2	12. Jan 2007
	BufferedReader.readLine() von anderem Thread aus beenden	Allgemeine Java-Themen	4	19. Okt 2006
D	Thread durch Mouse-Event beenden	Allgemeine Java-Themen	5	27. Sep 2006
F	Thread beenden	Allgemeine Java-Themen	5	5. Mrz 2006
R	11 GB File lesen ohne zu extrahieren Filedaten Bereich für Bereich adressieren dann mit Multi-Thread id die DB importieren	Allgemeine Java-Themen	3	21. Jun 2023
	Exception in thread "main" java.lang.Error: Unresolved compilation problem:	Allgemeine Java-Themen	7	6. Mrz 2023
	Wie stoppe ich diesen Thread	Allgemeine Java-Themen	4	17. Feb 2022
A	Thread.sleep Problem	Allgemeine Java-Themen	2	20. Dez 2021
J	Thread started nur einmal	Allgemeine Java-Themen	19	28. Jan 2021
W	Server-Thread schreibt nicht alle Dateien	Allgemeine Java-Themen	6	25. Jun 2020
	Logfile pro User / Thread	Allgemeine Java-Themen	7	24. Jun 2020
	Thread / Service abbrechen	Allgemeine Java-Themen	3	23. Jun 2020
	Ist meine static Helper Class Thread save?	Allgemeine Java-Themen	9	11. Feb 2020
P	Swing Exception in thread "AWT-EventQueue-0" java.lang.IndexOutOfBoundsException: npoints > xpoints.length \|\| npoints > ypoints.length	Allgemeine Java-Themen	5	29. Jan 2020
B	Thread.sleep() in EJB Container wie lösen?	Allgemeine Java-Themen	11	19. Dez 2019
S	Ist das Neuzuweisen von Feldern atomic und damit Thread-Safe?	Allgemeine Java-Themen	2	8. Apr 2019
S	Exception in thread "main" java.lang.NullPointerException at FamilienApp.main(FamilienApp.java:15)	Allgemeine Java-Themen	1	1. Jan 2019
J	Einen Thread in einer Schleife	Allgemeine Java-Themen	2	7. Sep 2018
E	HILFE !! Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/io/FileUtils	Allgemeine Java-Themen	4	4. Jun 2018
	Thread-Problem...	Allgemeine Java-Themen	2	20. Mai 2018
G	Thread-Programmierung	Allgemeine Java-Themen	5	13. Apr 2018
S	Datei wird nicht gefunden Thread.currentThread().getContextClassLoader().getResourceAsStream()	Allgemeine Java-Themen	1	12. Feb 2018
G	Beendet sich der Thread selbst?!	Allgemeine Java-Themen	3	8. Feb 2018
	Sleep wird ignoriert und der Thread wartet nicht	Allgemeine Java-Themen	1	3. Feb 2018
M	Array aus Thread Objekten erstellen	Allgemeine Java-Themen	2	3. Nov 2017
	Swing JOptionPane ohne denn Thread zu pausieren	Allgemeine Java-Themen	1	14. Jul 2017
M	Nanosekunden-Pause innerhalb einen Thread-Loops	Allgemeine Java-Themen	3	2. Mai 2017
E	Thread Exception	Allgemeine Java-Themen	6	28. Mrz 2017
	Binomialkoeffizient ausrechnen, Exception in thread "main" java.lang.StackOverflowError	Allgemeine Java-Themen	6	19. Jan 2017
T	Merkwürdiges Thread-Verhalten	Allgemeine Java-Themen	6	28. Sep 2016
K	Thread Problem	Allgemeine Java-Themen	6	28. Jun 2016
W	Thread sleep 30 sekunden - wenn keine Antwort bis dahin neu senden	Allgemeine Java-Themen	2	8. Jun 2016
H	Thread bleibt stehen bei jar in jar	Allgemeine Java-Themen	1	1. Jun 2016
J	Threads HTTP Request (Thread) dauert lange - in Android	Allgemeine Java-Themen	3	13. Apr 2016
F	CPU Last eines Thread ausfindig machen	Allgemeine Java-Themen	0	21. Feb 2016
V	Compiler-Fehler Exception in thread "AWT-EventQueue-0" java.lang.IndexOutOfBoundsException: Index: 125, Size: 125	Allgemeine Java-Themen	11	13. Okt 2015
	Threads Einen Thread sich selbst schließen lassen	Allgemeine Java-Themen	17	29. Aug 2015
P	Threads BufferedImage, Thread Concurrency	Allgemeine Java-Themen	1	18. Aug 2015
M	Klasse in separaten Thread ausführen.Wie genau?	Allgemeine Java-Themen	2	24. Jun 2015
	Thread blockiert Dialog	Allgemeine Java-Themen	1	1. Jun 2015
J	Thread wait()	Allgemeine Java-Themen	2	19. Mai 2015
V	Thread.sleep und InterruptedException?	Allgemeine Java-Themen	1	5. Apr 2015
G	Thread nicht von GC zerstört	Allgemeine Java-Themen	6	19. Feb 2015
J	Wie erschaffe ich einen sicheren Datenaustausch zwischen Thread und Nicht-Threads	Allgemeine Java-Themen	8	29. Jan 2015
	Thread blocken bis Taste gedrückt	Allgemeine Java-Themen	5	12. Jan 2015
T	Starten vom Thread	Allgemeine Java-Themen	3	9. Jan 2015
T	Wait/Notify() bei Thread	Allgemeine Java-Themen	6	10. Dez 2014
J	Exception in thread "main" java.lang.NoClassDefFoundError	Allgemeine Java-Themen	4	12. Nov 2014
M	Exception in thread "AWT-EventQueue-0"	Allgemeine Java-Themen	6	12. Okt 2014
Q	Thread wacht nicht auf	Allgemeine Java-Themen	7	5. Okt 2014
T	Fragen zum Thread-Thema	Allgemeine Java-Themen	4	19. Sep 2014
T	Threads Input/Output im Thread - Datei ohne Inhalt	Allgemeine Java-Themen	1	7. Sep 2014
T	Fragen zum Thread-Thema	Allgemeine Java-Themen	9	1. Aug 2014
C	Threads Variablen in einem Thread Aktualisieren	Allgemeine Java-Themen	17	11. Jun 2014
W	Threads Mit Thread und Runtime externe Programme öffnen	Allgemeine Java-Themen	0	8. Apr 2014
N	Thread interrupt Status debuggen	Allgemeine Java-Themen	6	1. Apr 2014
A	Thread: Code paralell ausführen in mehreren Instanzen	Allgemeine Java-Themen	1	23. Mrz 2014
E	Threads linkedlist/multi-thread problem	Allgemeine Java-Themen	3	30. Jan 2014
A	Thread Fehler absichtlich provozieren	Allgemeine Java-Themen	3	14. Jan 2014
B	Threads Java Thread kommunizieren	Allgemeine Java-Themen	12	3. Jan 2014
N	Thread Sicherheit im komplexen Datenmodell	Allgemeine Java-Themen	7	15. Nov 2013
K	Thread richtig benutzen	Allgemeine Java-Themen	3	28. Dez 2012
K	Exception in thread "AWT-EventQueue-1"	Allgemeine Java-Themen	2	3. Dez 2012
	Problem bei kleiner Thread-Übung	Allgemeine Java-Themen	2	19. Okt 2012
G	Thread erzeugt nicht plausible NullPointerException	Allgemeine Java-Themen	7	28. Sep 2012
H	Netbeans Warning bei Thread.sleep in Schleife	Allgemeine Java-Themen	4	27. Sep 2012
P	[Thread] Scheint nicht Sequenziell zu Arbeiten	Allgemeine Java-Themen	9	26. Aug 2012
A	eine test thread.join() frage	Allgemeine Java-Themen	2	16. Aug 2012
	Verständnisprobleme mit Thread Locks	Allgemeine Java-Themen	4	19. Jul 2012
G	Threads Thread bei Datenabfrage	Allgemeine Java-Themen	3	13. Jun 2012
S	Thread anhalten per Button ?	Allgemeine Java-Themen	3	12. Jun 2012
E	Thread Programmierung	Allgemeine Java-Themen	2	17. Mai 2012
S	Threads ServerSocket-Thread soll schlafen, bis er gebraucht wird	Allgemeine Java-Themen	2	7. Mai 2012
V	Thread schneller stoppen	Allgemeine Java-Themen	2	14. Apr 2012
V	anstatt thread.join() einfach while schleife?	Allgemeine Java-Themen	8	9. Apr 2012
B	Mausbewegung im Thread erkennen (hoch/runter)	Allgemeine Java-Themen	6	5. Apr 2012
G	Linux/C++/Pthreads auf JVM zugreifen, thread safe?	Allgemeine Java-Themen	10	3. Apr 2012
K	Threads Probleme mit Thread	Allgemeine Java-Themen	13	20. Mrz 2012
K	Threads Thread überprüfen	Allgemeine Java-Themen	3	15. Mrz 2012
Z	Threads Thread für einen Client	Allgemeine Java-Themen	9	12. Mrz 2012
M	Thread JavaFish	Allgemeine Java-Themen	10	11. Mrz 2012
G	Thread.sleep	Allgemeine Java-Themen	12	3. Mrz 2012
M	Threads Viele Aufrufe aus Thread, komisches Verhalten	Allgemeine Java-Themen	8	24. Feb 2012
B	Threads Main Thread warten auf abgebrochen Task warten lassen	Allgemeine Java-Themen	25	21. Feb 2012

Thread beenden

Schlagdraufunschluss_124

Aktives Mitglied

AndyJ

Bekanntes Mitglied

Schlagdraufunschluss_124

Aktives Mitglied

AndyJ

Bekanntes Mitglied

Thallius

Top Contributor

Schlagdraufunschluss_124

Aktives Mitglied

AndyJ

Bekanntes Mitglied

Schlagdraufunschluss_124

Aktives Mitglied

Thallius

Top Contributor

Schlagdraufunschluss_124

Aktives Mitglied

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen