Modèle futur

Supposons que vous ayez une méthode qui prend beaucoup de temps pour obtenir le résultat de l'exécution. ** Obtenez un bon au lieu d'attendre le résultat de l'exécution **. Il ne faut pas longtemps pour obtenir un bon. Le bon à ce moment s'appelle le rôle Future. Le thread qui a reçu le voucher utilisera plus tard le rôle Future pour recevoir le résultat de l'exécution. Si le résultat de l'exécution est disponible, vous le recevrez immédiatement, et sinon, vous attendez de pouvoir.

(Voir ce manuel pour le code complet)

`Main.java`


public class Main { 
    public static void main(String[] args) { 
        ...
        Host host = new Host(); 
        Data data1 = host.request(10, 'A'); 
        Data data2 = host.request(20, 'B'); 
        Data data3 = host.request(30, 'C'); 

        try { 
            Thread.sleep(2000); 
        } catch (InterruptedException e) { 
        } 
 
        System.out.println("data1 = " + data1.getContent()); 
        System.out.println("data2 = " + data2.getContent()); 
        System.out.println("data3 = " + data3.getContent()); 
    } 
}

`Host.java`


public class Host { 
    public Data request(final int count, final char c) { 
        final FutureData future = new FutureData();  //Créer un bon

        new Thread() { 
            public void run() { 
                RealData realdata = new RealData(count, c); 
                future.setRealData(realdata); 
            } 
        }.start(); 

        return future;  //Bon de retour
    } 
}

`Data.java`


public interface Data { 
    public abstract String getContent(); 
}

`Future.java`


public class FutureData implements Data { 
    private RealData realdata = null; 
    private boolean ready = false; 
    public synchronized void setRealData(RealData realdata) { 
        if (ready) { 
            return;     // balk 
        } 
        this.realdata = realdata; 
        this.ready = true; 
        notifyAll(); 
    } 
    public synchronized String getContent() { 
        while (!ready) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
            } 
        } 
        return realdata.getContent(); 
    } 
}

La classe Host crée d'abord une instance de FutureData. Cette instance est la valeur de retour. Puis démarrez un nouveau thread et créez une instance de RealData dedans. La création d'une instance de RealData prend du temps. Une fois l'instance créée, appelez la méthode setRealData pour la définir dans l'instance FutureData.

La classe FureData est une classe de bon. Le champ realData est un champ qui contient une instance de RealData qui sera créée. Ce champ est attribué par la méthode setRealData. La méthode getContent est une méthode pour obtenir les données réelles. Attendez que realdata soit défini par setRealData. S'il est défini, il retourne immédiatement, et s'il n'est pas défini, il attend. Les threads en attente sont réveillés en appelant notifyAll dans setRealData.

Personnage

Rôle du client Le rôle Client fait une demande au rôle Host et reçoit immédiatement le rôle VirtualData en conséquence (valeur de retour). Le rôle VirtualData reçu ici est en fait le rôle Future. Le rôle Client n'a pas besoin de savoir si la valeur de retour est un rôle RealData ou un rôle Future. Dans l'exemple de programme, la classe Main a joué ce rôle.

Rôle hôte Le rôle Host crée un nouveau thread et commence à créer le rôle RealData. D'autre part, le rôle Future est retourné au rôle Client en tant que rôle Virtual Data. Dans l'exemple de programme, la classe Host a joué ce rôle.

Rôle de données virtuelles Le rôle VirtualData est un rôle qui assimile le rôle Future au rôle RealData. Dans l'exemple de programme, l'interface de données a joué ce rôle.

Rôle de données réelles Le rôle RealData est un rôle qui représente des données réelles. La création de cet objet prend du temps. Dans l'exemple de programme, la classe RealData a joué ce rôle.

Rôle futur Le rôle Future est un rôle passé du rôle Host au rôle Client en tant que voucher pour le rôle RealData. Le rôle Future se comporte comme un rôle Virtual Data pour le rôle Client. Lorsqu'il est exploité à partir du rôle Client, le thread attend avec attente que le rôle RealData soit terminé. Dans l'exemple de programme, la classe FureData a joué ce rôle.

Conseils pour élargir vos pensées

Le rôle du futur qui ne peut pas attendre Il est également possible d'implémenter la méthode getContent de manière asynchrone. Au lieu de l'histoire déroutante de la création d'un nouveau thread dans la méthode getContent, vous pouvez utiliser le modèle Balking pour «rentrer à la maison si vous ne pouvez pas».

Modèle de rappel et futur Si vous souhaitez attendre la fin du traitement et obtenir la valeur de retour, vous pouvez penser à une méthode appelée ** callback **. Le rappel est une méthode dans laquelle le thread démarré par le rôle Hôte lorsque le traitement est terminé rappelle la méthode du rôle Client.

Résumé de «Modèles de conception appris en langage Java (édition multithread)» (partie 11)

Modèle futur

Main.java

Host.java

Data.java