Thread.join () ne fonctionne pas lors de l'exécution du thread par ExecutorService

Allez:

Ceci est mon code:

public static void main(String[] args) {
        System.out.println("program started");
        ExecutorService executor = Executors.newCachedThreadPool();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread finished");
            }
        });
        executor.execute(thread);
        try {
            thread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("thread joined");

    }

Quand je commence mon discussion comme montré ci - dessus, thread.join()ne fonctionne pas et il n'attend pas le fil à terminer. Je dois exécuter mon fil par un ExecutorService et aussi attendre que le fil soit terminé. mais mon code ne fonctionne pas bien. Quelqu'un peut-il m'aider?

Pourquoi je ne suis pas en utilisant l' avenir au lieu de cette discussion ?

parce que parfois je dois interrompre mon discussion et attendre que cette discussion soit terminé. mais quand je résilie un avenir , future.get()obtient une exception et ne l' attend pas du fil à terminer.

Je présente mes excuses à l'avance si la grammaire de ma phrase est incorrecte. parce que je ne peux pas bien parler l'anglais.

GhostCat de Monica C.:

La réponse est simple: ne pas faire.

Ne pas mélanger les couches d'abstractions comme celui - ci. L'interface Executor ne execute()threads. Il faut runnables . Peu importe que vous passez un objet de discussion à, votre fil ne sera pas utilisé du tout, en plus d' un appel à la run()méthode.

Le mélange « couche basse » fils de fer nu avec un service Executor Abstraite est tout simplement une mauvaise idée.

Le point entier de ce pool de threads concept est que vous ne pas essayer de contrôler les fils sous - jacents. Il n'y a tout simplement pas de point dans l' attente d'un fil mis en commun à la fin . Un pool de threads garde autour des fils, des fils parce que l' établissement est une des opérations coûteuses (relativement). Donc , ils ne se terminent pas, mais vivent, à faire d' autres travaux à l'avenir.

La vraie réponse ici: soit ne pas utiliser ce service d'exécuteur testamentaire, ou venir chercher une solution qui fonctionne avec ce concept (sans que vous allez et à faire des trucs de bas niveau sur le côté).

Et la réponse « real »: pas en arrière, et nous dire au sujet du problème « réel » vous avez l'intention de résoudre cette façon.