Faites de la place pour JavaSpaces, partie 1

Cet article commence un deuxième fil de la série Jiniology . En juin, Bill Venners a lancé Jiniology avec un aperçu de la technologie Jini - une nouvelle infrastructure puissante pour la création et le déploiement de systèmes distribués organisés en fédérations de services. Ce fil de discussion, qui sera présenté tous les deux mois dans cette colonne, se concentre sur les JavaSpaces,un service Jini de base de Sun Microsystems qui fournit un moyen de haut niveau de créer des applications collaboratives et distribuées. Si vous créez des applications avec Jini, vous voudrez savoir comment utiliser JavaSpaces pour coordonner les participants dans une fédération Jini. Mais il est également important de se rappeler que vous pouvez utiliser JavaSpaces séparément de Jini, en tant qu'outil de création de systèmes distribués généraux en Java. Dans les deux cas, JavaSpaces vaut le coup d'œil, car il peut considérablement faciliter la conception et le codage des applications distribuées.

Faites de la place pour JavaSpaces: Lisez toute la série!

  • Partie 1. Facilitez le développement d'applications distribuées avec JavaSpaces
  • Partie 2. Construire un serveur de calcul avec JavaSpaces
  • Partie 3. Coordonnez vos applications Jini avec JavaSpaces
  • Partie 4. Explorez les transactions Jini avec JavaSpaces
  • Partie 5: Rendez votre serveur de calcul robuste et évolutif

Dans cette série, nous commencerons par vous présenter le modèle de programmation JavaSpaces unique, qui est assez différent des autres outils réseau et distribués que vous connaissez peut-être. Dans les articles suivants, nous couvrirons les détails de l'API JavaSpaces et comment vous pouvez l'utiliser pour coller des processus ensemble dans une application distribuée, et décrire comment JavaSpaces interagit avec d'autres composants de Jini. Tout au long de la série, vous verrez que JavaSpaces est simple (l'API ne comprend qu'une poignée d'opérations), expressif (un grand nombre de problèmes peut être résolu à l'aide de JavaSpaces) et puissant (vous pouvez créer des systèmes distribués sophistiqués avec de petites quantités du code JavaSpaces).

Commençons.

Un nouveau modèle de calcul distribué

La création d'applications distribuées avec des outils réseau conventionnels implique généralement la transmission de messages entre processus ou l'appel de méthodes sur des objets distants. Dans les applications JavaSpaces, en revanche, les processus ne communiquent pas directement, mais coordonnent plutôt leurs activités en échangeant des objets via un espace ou une mémoire partagée. Un processus peut writecréer de nouveaux objets dans un espace, des takeobjets provenant d'un espace ouread(faire une copie) d'objets dans un espace; La figure 1 représente plusieurs processus (représentés par Dukes) interagissant avec des espaces à l'aide de ces opérations. Lors de la prise ou de la lecture d'objets, les processus utilisent une correspondance simple, basée sur les valeurs des champs, pour trouver les objets qui leur importent. Si un objet correspondant n'est pas trouvé immédiatement, un processus peut attendre jusqu'à ce qu'il arrive. Dans JavaSpaces, contrairement aux magasins d'objets conventionnels, les processus ne modifient pas les objets dans l'espace ou n'appellent pas leurs méthodes directement - alors que là, les objets ne sont que des données passives. Pour modifier un objet, un processus doit explicitement le supprimer, le mettre à jour et le réinsérer dans l'espace.

Les espaces sont des magasins d'objets avec plusieurs propriétés importantes qui contribuent à faire de JavaSpaces un outil puissant et expressif. Regardons de plus près:

  • Les espaces sont partagés: de nombreux processus distants peuvent interagir simultanément avec un espace - l'espace lui-même gère les détails de l'accès simultané, vous laissant vous concentrer sur la conception des protocoles de haut niveau entre vos processus.

  • Les espaces sont persistants: les espaces fournissent un stockage fiable pour les objets. Lorsque vous stockez un objet dans un espace, il y restera indéfiniment jusqu'à ce qu'il soit supprimé. Vous pouvez également demander une durée de bail pendant laquelle un objet doit être stocké. Une fois stocké dans l'espace, un objet y restera jusqu'à la fin de son bail (qui peut être renouvelé) ou jusqu'à ce qu'un processus le supprime explicitement. Nous discuterons plus en détail des baux plus loin dans cette série.

  • Les espaces sont associatifs: les objets dans un espace sont localisés via une recherche associative, et non par emplacement mémoire ou par identifiant. La recherche associative fournit un moyen simple de trouver les objets qui vous intéressent en fonction de leur contenu, sans avoir à savoir comment l'objet est appelé, qui l'a créé ou où il est stocké. Pour rechercher un objet, vous créez un modèle (un objet avec certains ou tous ses champs définis sur des valeurs spécifiques, et les autres laissés nullpour agir comme des caractères génériques). Un objet dans l'espace correspond à un modèle s'il correspond exactement aux champs spécifiés du modèle. Vous verrez qu'avec la recherche associative, vous pouvez facilement exprimer des requêtes pour des objets tels que "Y a-t-il des tâches à calculer?" ou "Y a-t-il des réponses au premier facteur que j'ai demandé? "

  • Les espaces sont sécurisés sur le plan transactionnel: JavaSpaces utilise le service de transaction de Jini pour s'assurer qu'une opération sur un espace est atomique (soit l'opération est appliquée, soit elle ne l'est pas). Les transactions sont prises en charge pour des opérations uniques sur un seul espace, ainsi que pour plusieurs opérations sur un ou plusieurs espaces (soit toutes les opérations sont appliquées, soit aucune ne l'est). Comme vous le verrez plus loin dans la série, les transactions sont un moyen important de gérer une défaillance partielle.

  • Les espaces vous permettent d'échanger du contenu exécutable: dans un espace, les objets ne sont que des données passives - vous ne pouvez pas les modifier ni appeler leurs méthodes. Cependant, lorsque vous lisez ou prenez un objet dans un espace, une copie locale de l'objet est créée. Comme pour tout autre objet local, vous pouvez modifier ses champs publics et invoquer ses méthodes, même si vous n'avez jamais vu un objet comme lui auparavant. Cette fonctionnalité vous offre un mécanisme puissant pour étendre le comportement de vos applications à travers un espace.

Au fur et à mesure de l'avancement de cette série, nous vous montrerons comment ces propriétés jouent un rôle clé pour vous permettre de créer des applications distribuées qui fonctionnent bien dans l'environnement Jini, où la mise en réseau est souvent spontanée, et les processus rejoignent et quittent le calcul dynamiquement, parfois à cause du périphérique ou panne de réseau.

Origines de JavaSpaces

Nous avons décrit JavaSpaces comme un nouveau modèle de calcul distribué, mais ses origines remontent à l'Université de Yale au début des années 1980. Là, le Dr David Gelernter a développé un outil appelé Linda pour créer des applications distribuées. Linda se compose d'un petit nombre d'opérations combinées à un magasin persistant appelé espace tuple. Ces opérations sont orthogonales à tout langage de programmation particulier; ils font partie d'un langage de coordination qui peut être ajouté à n'importe quel autre langage de calcul.Le résultat de la recherche Linda a été surprenant: en utilisant un magasin d'objets avec un petit nombre d'opérations simples, vous pouvez facilement implémenter une grande classe de problèmes parallèles et distribués en utilisant des techniques qui atténuent de nombreux pièges de la construction de systèmes en réseau. En d'autres termes, les systèmes spatiaux sont non seulement simples (ne nécessitant que quelques opérations), mais aussi expressifs (se prêtant bien à la résolution de nombreux problèmes distribués).

Le travail du Dr Gelernter a inspiré le service JavaSpaces de Sun et a également influencé la conception des composants de recherche et de découverte de la technologie de base Jini (que vous verrez au fur et à mesure que la série Jiniology progresse). Alors que JavaSpaces a hérité du modèle spatial de Linda, les concepteurs de JavaSpaces ont mis à jour le modèle de manière significative, en exploitant la puissance des objets Java, Jini, RMI et la sérialisation d'objets.

JavaSpaces en contexte

Notre description jusqu'à présent a été un peu abstraite, alors considérons quelques exemples de vraies applications distribuées que vous pouvez modéliser comme des processus échangeant des objets à travers des espaces.

Systèmes de chat

Considérez un simple système de discussion multi-utilisateurs, dans lequel un espace sert de zone de discussion contenant tous les messages constituant une discussion. Pour parler, un participant dépose des objets de message dans l'espace. Tous les membres du chat attendent que de nouveaux objets de message apparaissent, les lisent et affichent leur contenu. Les arrivées tardives peuvent examiner les objets de message existants dans l'espace pour revoir la discussion précédente. En fait, comme l'espace est persistant, un nouveau participant peut voir la discussion longtemps après que tout le monde soit parti, et les participants peuvent même revenir beaucoup plus tard pour reprendre la conversation là où ils l'ont laissée. La liste des participants au chat peut également être conservée dans l'espace et mise à jour chaque fois que quelqu'un rejoint ou quitte la conversation.

Serveurs de calcul

Pensez maintenant à analyser les données des radiotélescopes en temps réel pour détecter des signes de vie extraterrestre (comme le fait le projet SETI @ home). Ces données sont volumineuses et leur analyse est un travail intensif en calcul qui est bien adapté au calcul parallèle par un réseau d'ordinateurs - en d'autres termes, un «serveur de calcul». En utilisant la technologie JavaSpaces, une série de tâches - par exemple, une tâche par bloc de données à analyser - est écrite dans l'espace. Chaque ordinateur participant recherche dans l'espace une tâche, la supprime, effectue le travail de calcul nécessaire, dépose le résultat dans l'espace, puis continue de rechercher d'autres tâches. Cette approche évolue naturellement: elle fonctionne de la même manière qu'il y ait 10 ordinateurs disponibles ou 1000. L'approche fournit également un équilibrage de charge naturel , car chaque travailleur prend exactement autant de travail qu'il peut en gérer dans un temps donné, les ordinateurs lents effectuant moins de travail et les ordinateurs rapides en faisant plus.

Systèmes de courtage

Comme troisième exemple, considérons un système d'enchères en ligne qui réunit acheteurs et vendeurs de biens et de services. Supposons que vous, en tant qu'acheteur potentiel, décrivez l'article (comme une voiture) que vous souhaitez acheter et le prix que vous êtes prêt à payer, enveloppez les informations dans une entrée et écrivez l'entrée de recherche souhaitée à un espace. Dans le même temps, les vendeurs potentiels surveillent en permanence l'espace pour l'arrivée des entrées désirées qui correspondent aux articles de leur inventaire. Par exemple, les concessionnaires Mazda surveillent l'espace pour les entrées qui décrivent Mazdas, tandis que les concessionnaires de voitures d'occasion surveillent l'espace pour toutes les demandes de voitures d'occasion. Lorsqu'une demande correspondante est trouvée et lue, un vendeur potentiel écrit une entrée d'offre dans l'espace, indiquant un prix d'offre. En tant qu'acheteur potentiel, vous surveillez en permanence l'espace pour les enchères sur vos demandes en suspens, et,lorsque vous en trouvez une qui est acceptable, vous supprimez les enchères et contactez le vendeur (éventuellement via l'espace via une autre entrée).

Un bref aperçu de l'API

Il est maintenant temps de présenter l'API JavaSpaces. Comme nous l'avons déjà dit, c'est simple; en fait, dans le reste de cet article, nous couvrirons tout ce que vous devez savoir (sauf quelques détails mineurs) à ce sujet. Cependant, avant de décrire l' JavaSpaceinterface et ses méthodes, nous devons d'abord parler des entrées.

Entrées

Un objet qui est stocké dans un espace est appelé un

entrée.

Pour être une entrée, un objet doit simplement implémenter le

Entry

interface. À titre d'exemple, définissons une entrée de message que vous pouvez écrire dans un espace:

import net.jini.core.entry.Entry;

public class Message implémente Entry {public String content;

// un constructeur sans argument public Message () {}}

Ici, nous avons défini une Messageclasse avec un champ de chaîne qui contiendra le contenu du message. Parce que nous voulons utiliser cette classe avec des espaces, nous devons implémenter l'interface net.jini.core.entry.Entry, qui se trouve dans le package net.jini.core.entry. Il est important de souligner qu'il Entrys'agit d'une interface de marqueurs; en d'autres termes, l'interface ne contient ni constantes ni méthodes et ne nécessite donc aucun travail particulier à implémenter, autre que l'ajout implements Entryà votre définition de classe.

Outre l'implémentation de l' Entryinterface, il existe quelques autres conventions que nos entrées doivent suivre. Nous aurons plus à dire sur les raisons dans les articles suivants, mais pour l'instant, nous allons simplement regarder les grandes lignes. Une entrée doit avoir un constructeur public qui ne prend aucun argument (un soi-disant constructeur sans argument ); cette exigence découle de la sérialisation sous-jacente qui se produit lorsque les entrées sont transférées dans et hors des espaces. Notez que notre définition de Messagecontient un constructeur sans argument. Une autre convention est que les champs d'une entrée doivent être déclaréspublic; cela permet à d'autres processus de trouver vos entrées dans des espaces via une recherche associative, basée sur les valeurs de ces champs. Une troisième convention est que les champs d'une entrée doivent contenir des références à des objets, plutôt que des types primitifs (autrement dit, si vous devez définir un champ de type primitif tel que int, vous devez utiliser la classe wrapper correspondante à la Integerplace). Pour vous assurer de couvrir toutes vos bases dans la définition des entrées, nous vous recommandons de vous référer aux principes, modèles et pratiques JavaSpaces , ou aux spécifications JavaSpaces de Sun Microsystems pour plus de détails. Comme mentionné, nous aborderons également certains des points les plus fins dans des articles ultérieurs.

En dehors de ces exigences, une entrée est comme toute autre classe Java; vous pouvez l'instancier, appeler ses méthodes et attribuer des valeurs à ses champs publics. Maintenant que nous avons défini une Messageclasse d'entrée, voyons quelles opérations sont disponibles pour interagir avec les entrées dans les espaces.

L'interface JavaSpace

Pour interagir avec un espace, vous devez obtenir l'accès à un objet qui implémente l' JavaSpaceinterface. Il existe de nombreuses façons d'obtenir l'accès à un tel objet (vous pouvez, par exemple, utiliser la recherche Jini ou le registre RMI) et nous en parlerons en détail dans le prochain article. Pour l'instant, nous allons nous concentrer sur l' JavaSpaceinterface elle-même.