# Wie kann ich eine Methode in einem Thread starten?



## Loki2 (7. August 2008)

Hallo

Ich habe ein kleines Thread Problem. Ich möchte eine Methode in einem separaten Thread aufrufen damit ich die Ausführung der Methode unterbrechen kann in dem ich den Thread kille nur leider weiss ich nicht wie ich das bewerkstelligen soll.

Folgendes habe ich probiert:


```
Thread mythread = new Thread(result= myMethod(stringParam1, true));
```
mythread ist aber leider dummerweise immer null.

Wie gehts richtig und wie kill ich den Thread dann? Reicht ein mythread.interrupt() ? Alles andere ist ja deprecated.

Ich hoffe ihr könnt mir weiterhelfen.

Gruß und so
Loki2


----------



## Xandro (7. August 2008)

Moin,

Du willst also einfach eine Methode aufrufen, die innerhalb eines Thread liegt?
Weil in Deinem Beispiel rufst Du nur den Konstruktor auf, das verwirrt irgendwie.

Ich bin mir noch nicht ganz sicher was Du genau meinst, deshalb poste ich einfach mal ein ungefähres Beispiel:

```
package snippets.tutorials.loki2;

/**
 * 
 * @author Xandro
 */
public class Test {

    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        t.doSomething();
    }
}

class MyThread extends Thread {

    @Override
    public void run() {
        while (true) {
            // mach was
        }
    }

    public void doSomething() {
        // mach noch was
    }
}
```

Meinst Du sowas oder habe ich Dich nur nicht richtig verstanden?
Und ja, Du kannst einfach interrupt() aufrufen, um den Thread stillzulegen.

Gruß,
Xan


----------



## Loki2 (7. August 2008)

Hi,

erstmal Danke für die Antwort.

Hmm...Ja vielleicht habe ich mich falsch ausgedrückt.

Also normalerweise rufe ich die Methode einfach so auf:


```
result= myMethod(stringParam1, true);
```
Diese Ausfürhung soll jetzt aber in einem separaten Thread gestartet werden so dass ich das ganze mit dem killen des Threats abbrechen kann.

Ist es jetzt irgendwie klarer?


----------



## Xandro (7. August 2008)

Moin,

Neuer Versuch, neues Glück:


```
package snippets.tutorials.loki2;

/**
 * 
 * @author Xandro
 */
public class Test {

    public static void main(String[] args) {
        MyThread t = new MyThread(new OtherClass());
        t.start();
    }
}

class OtherClass {

    public void callMethod(String param, boolean bool) {
        // mach was
    }
}

class MyThread extends Thread {

    private OtherClass oc;

    public MyThread(OtherClass oc) {
        this.oc = oc;
    }

    @Override
    public void run() {
        while (true) {
            oc.callMethod("Blubb", true);
        }
    }
}
```

Damit müsste Deine Methode solange aufgerufen werden, bis der Thread gekillt wird.
Du musst also ein Objekt der Klasse mit übergeben, welche die Methode bereitstellt.
Dieses Objekt wird dann in einer Klassenvariable gespeichert und die Methode selbst in der run-Methode aufgerufen.

Das sollte meines Erachtens funktionieren. Eventuell gibt es noch schönere Lösungen, aber das fiel mir im Moment grad ein.

Gruß,
Xan


----------



## Thomas Darimont (7. August 2008)

Hallo,

heutzutage verwendet man dazu den java.util.concurrent.ExecutorService.
Schau mal hier:

```
/**
 * 
 */
package de.tutorials;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @author Thomas.Darimont
 * 
 */
public class FutureExample {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();

        Future<String> future = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return op();
            }
        });

        String result = null;
        while (result == null) {
            try {
                result = future.get(1, TimeUnit.SECONDS);
            } catch (TimeoutException e) {
                //e.printStackTrace();
                System.out.println("Try again...");
            }
        }
        System.out.println("Got result: " + result);
        
        executorService.shutdownNow();

    }

    static String op() throws Exception {
        TimeUnit.SECONDS.sleep(5L);
        return String.valueOf(System.currentTimeMillis());
    }

}
```

siehe auch;
http://www.tutorials.de/forum/java/284282-methode-nach-bestimmter-zeit-beenden.html
http://www.tutorials.de/forum/java/274056-fragen-threads-und-executorservice.html
http://www.tutorials.de/forum/java/276266-komplizierter-java-queue-mechanismus.html

Gruß Tom


----------

