Threadübergreifend Code ausführen mit übergebenen Parameter

Wenn man Actionen in einem anderen Thread ausführen möchte, macht man dies normalerweiße mit

loop.post(new Runnable()...)

Das Problem ist jedoch, wenn ich eine lokale Variable habe, kann ich diese nicht an den anderen Thread uebergeben...
Ich habe das Problem gelöst, in dem ich eine Klasse geschrieben habe die Runnable implementiert.

/**
 * Um Code in einem Anderen Thread auszufuehren
 * @author Fasibio
 *
 */
public abstract class ThreadAcrossRunable implements Runnable {

    protected Object[] arguments; 
    /**
     * Argumente die man in anderen Thread übergeben will
     * @param args
     */
    public ThreadAcrossRunable (Object[] args){
         arguments = args;
    }


    @Override
    public void run() {
        runthis(arguments);

    }

    /**
     * In dieser Methode wird der entsprechende Code ausgeführt
     * @param args
     */
    public abstract void runthis(Object[] args);


}

Nun kann man z.B.: so das ganze aufrufen:

Object[] args = {object1, object2};
        mainLoop.post(new ThreadAcrossRunable(args) {

           @Override
            public void runthis(Object[] args) {
            machwas...
        }
        });

So kann wie gewohnt mit inneren anonymen Klassen arbeiten und trotzdem Parameter übergeben.
Wenn ihr einen Besseren Lösungweg habt freu ich mich ihn zu hören

Fabian Simon

— geändert am 12.06.2014, 15:01:48

Hallo Alex,
kannst du da beispiel geben, wie das das meinst ?
Da wenn ich protected final Object[] arguments; statt protected Object[] arguments; mache, macht dies ja keinen Großen unterschied.
Somit glabe ich ja nicht das du das meinst oder?
Oder meinst du das ganze so zu machen :

public void irgendeineMethode(Object obj1,Object obj2){
  final Object[] args = {obj1,obj2};
  mainLoop.post(new Runnable(){
   public void run(){
  //mach was mit args
System.out.println(args[0]);
}
});
}

Das würde auch gehen .... hat eigentlich auch nur wenige nachteile.
Der einziege Nachteil ist, das dem finalen object nicht neu inizialisiert werden kann.
Dies ist, denk ich, jedoch nur selten von nöten...
Danke dir für den Denkanstoß
Gruß
Fabian

— geändert am 09.09.2014, 09:35:26

Ich habe das ganze noch generisch gemacht....
Somit muss man sich nicht mehr um das casten kümmern:

/**
 * Um Code in einem Anderen Thread auszufuehren
 * @author Fasibio
 *
 */
public abstract class ThreadAcrossRunable<G> implements Runnable {
protected G[] arguments; 
/**
 * Argumente die man in anderen Thread &uuml;bergeben will
 * @param args
 */
public ThreadAcrossRunable (G[] args){
     arguments = args;
}


@Override
public void run() {
    runthis(arguments);

}

/**
 * In dieser Methode wird der entsprechende Code ausgef&uuml;hrt
 * @param args
 */
public abstract void runthis(G[] args);

}

Das Ganze kann wie folgt aufgerufen werden:

    Parent[] p = {new Child(),new Child()};
    mainLoop.post(new ThreadAcrossRunable<Parent>(p) {

        @Override
        public void runthis(Parent[] args) {
            // mach was

        }
    });