Cela fait déjà une bonne dizaine de fois que je peste pour la même chose sur mon projet actuel : le chaînage des traitements dans tous les sens avec des fils de partout. Un schema très récurrent est "j'ai besoin de faire quelque chose après un traitement générique qui tourne dans un thread, mais cette chose dépend de paramètres qui ne sont jamais les mêmes suivant de où j'appelle mon traitement. Bon bah je vais rajouter pleins de paramètres à la méthode de mon traitement et me les traîner sur toute ma stack pour pouvoir faire ce qu'il faut à la fin". NOON ! Il faut arrêter les conneries. Si vous avez un traitement qui fonctionne gardez le comme ça, ATOMIQUE. Si les traitements qui suivent sont différents en fonction des appelants utilisez des Callbacks !

Un petit (mauvais) exemple :

public class Treatment {
    public static void doMyTreatment(int value1, int value2, int parameter1, int parameter2) {
        new Thread(new Runnable() {
            public void run() {
                /// DO a realy long treatment...
                /// very long...
                int res = value1 + value2;

                if (parameter1 == 0) {
                    doSomthg();
                } else if (parameter1 == 1) {
                    if (parameter2 == 0){
                        goSomewhere();
                } else {
                        cook();
                }
            }
        } 
    }
}

public class Caller1 {
    public void call() {
        Treatment.doMyTreatment(1, 2, 0, 0);
    }
}

public class Caller2 {
    public void call() {
        Treatment.doMyTreatment(1, 2, 1, 1);
    }
}

Ici vous avez les paramètres 1 et 2 qui vont influencer le "quoi" faire après le traitement des valeurs 1 et 2... C'est mal, ça va vite devenir une grosse pelote de laine au fil des ajouts de fonctionnalités. Alors que si vous aviez fait :

public class Treatment {
    public static void doMyTreatment(int value1, int value2, Runnable callback) {
        new Thread(new Runnable() {
            public void run() {
                /// DO a realy long treatment...
                /// very long...
                int res = value1 + value2;

                callback.run();
            }
        } 
    }
}

public class Caller1 {
    public void call() {
        Treatment.doMyTreatment(1, 2, new Runnable() {
            public void run() {
                StaticClass.doSomthg();
            }
        }
    }
}

public class Caller2 {
    public void call() {
        Treatment.doMyTreatment(1, 2, new Runnable() {
            public void run() {
                StaticClass.cook();
            }
        }
    }
}

C'est quand même plus propre. Bon là j'utilise de simples Runnable en callbacks, du coup je n'ai pas possibilité de passé des paramètres à ma méthode run mais ce n'est pas compliqué de définir votre interface perso à la place de Runnable.

Autre point, vous pouvez remplacer la callback par une List pour être capable de chaîner plusieurs traitements.

Et voilà...