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 futures, promises ou 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 et/ou son obtention se fera « 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 futures peut être implicite (à chaque utilisation une future obtient automatiquement sa valeur, comme si c'était un nombre ordinale 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'une future peut être appelé "stinging" ou "forcing". Les futures explicites peuvent être implémenté comme une bibliothèque, tandis que les futures implicites nécessitent un support du langage.

La publication originale de Baker et Hewitt décrit les futures implicites, qui sont naturellement supportées 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 futures explicites, pour répondre aux difficultés d'implémentation efficiente des futures implicites dans certains langages. La difficulté est que les langages ne sont pas forcément capable de gérer les futures pour des types de données primitives comme les integers. Par exemple, une instruction add ne sait pas comment gérer 3 + future factorial(100000). En pur object 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]