Futures (informatique)

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Futures et Futur.

En programmation, les notions de futurs (« futures »), promesses (« promises ») ou délais (« delay ») font référence à des techniques de synchronisation pour certains langages concurrents. Il s'agit d'abstractions qui servent de proxy pour un résultat non-connu au moment où il est référencé pour la première fois, car son calcul ou son obtention se feront « plus tard » à l'exécution.

Le terme générique de promise (« promesse ») a été proposé par Daniel P. Friedman et David Wise en 1976[1] ; Peter Hibbard le dénommait eventual[2] à la même époque. Le concept similaire de future a été introduit en 1977 dans une publication de Henry Baker (en) et Carl Hewitt[3].

Les termes future, promise et delay sont la plupart du temps interchangeables, bien que certains programmeurs soulignent des différences entre future et promise. L'action consistant à attribuer sa valeur à une promise est la plupart du temps notée resolving, fulfilling ou binding.

Implicite vs explicite[modifier | modifier le code]

L'utilisation de futurs peut être implicite : à chaque utilisation un futur obtient automatiquement sa valeur, comme si c'était un nombre ordinal ; ou explicite : l'utilisateur doit appeler une fonction pour obtenir sa valeur, comme la méthode get de java.util.concurrent.Future en Java. Obtenir une valeur d'un futur peut être appelé "stinging" ou "forcing". Les futurs explicites peuvent être implémentés comme une bibliothèque, tandis que les futurs implicites nécessitent un support du langage.

La publication originale de Baker et Hewitt décrit les futurs implicites, qui sont naturellement supportés par le Modèle d'acteur de la pure programmation orientée objet dans des langages de programmation comme Smalltalk. La publication de Friedman et Wise décrit uniquement les futurs explicites, pour répondre aux difficultés d'implémentation efficiente des futurs implicites dans certains langages. La difficulté est que les langages ne sont pas forcément capable de gérer les futurs pour des types de données primitives comme les entiers. Par exemple, une instruction add ne sait pas comment gérer 3 + future factorial(100000). En pur objet ou un langage d'acteur ce problème peut être résolu en envoyant future factorial(100000), le message +[3] demande à la future d'ajouter 3 à lui-même et de retourner le résultat. Notez que le passage de message fonctionnera même si aucun stinging/forcing n'est utilisé quand factorial(100000) fini de s'exécuter.

Références[modifier | modifier le code]

  1. Friedman, Daniel (1976). « The Impact of Applicative Programming on Multiprocessing » International Conference on Parallel Processing, pp. 263-272.. 
  2. Hibbard, Peter (1976). « Parallel Processing Facilities » New Directions in Algorithmic Languages, (ed.) Stephen A. Schuman, IRIA, 1976.. 
  3. Henry Baker and Carl Hewitt (August 1977). « The Incremental Garbage Collection of Processes » Proceedings of the Symposium on Artificial Intelligence Programming Languages, SIGPLAN Notices 12. 

Liens externes[modifier | modifier le code]