Discussion :

[dedicare]

Bonjour,

Je travaille actuellement sur une application qui, au cours de son fonctionnement, peut générer énormement d'objets de même type, par exemple 10 000 objets de type identique.

Ces objets suivent les régles suivantes :
1. Un objet contient des meta données et des données ;
2. Les objets de même type contiennent les mêmes méta données;
3. Deux objets de même type se distinguent par leurs données ;

J'ai déjà allégé l'application en faisant en sorte que les objets, ayant les mêmes méta données donc de même type, utilisent une structure commune pour stocker/rechercher leurs méta données.

J'aurai voulu savoir :

1. Si il était possible ou non d'aller plus loin c'est-à-dire qu'au lieu d'avoir 10 000 objets du type final d'avoir 10 000 objets, plus petit, qui interrogeraient un seul objet du type final en lui fournissant ses caractéristiques ?
2. Si il y a autre solution plus efficace.
3. Si la solution présentée en 1. apportera vraiment une optimisation ou pas ?

Je vous remercie pour votre aide par avance.

[natha]

Euh... rien compris... désolé

[herve91]

A tout hasard, est-ce que tes objets sont immuables ?
Manipuler des objets immuables permettrait d'éviter de produire des instances multiples inutiles, en conservant dans un pool d'objets l'ensemble des instances.
Pour créer une nouvelle instance, il faut alors passer par une méthode statique de fabrication, de façon à renvoyer le cas échéant une instance déjà existante.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Node {
 
  private int x;
  private int y;
 
  private static Map pool = new HashMap();
  private static Node key = new Node();
 
  public static Node newInstance(int x, int y) {
    key.x = x;
    key.y = y;
    Node node = (Node) pool.get(key);
    if (node == null) {
      node = key;
      pool.put(key, node);
      key = new Node();
    }
    return node;
  }
 
  public boolean equals(Object o) {
    if (o instanceof Node) {
      Node node = (Node) o;
      return node.x == x && node.y == y;
    }
    return false;
  }
 
  public int hashCode() {
    return x + y;
  }
}

[dedicare]

Oui, en effet, mes objets sont immuables et donc j'utilise aussi le principe cité dans le message ci-dessus.

En fait, j'aurai voulu savoir il était judicieux et utile qu'au lieu de créer 10 000 objets portant tous un jeu de données distincts, des méta données identiques et des fonctions métiers identiques de ne créer que 10 000 objets intermédiaires, plus petits, qui transmettraient leur jeu de données en 1 seul objet contenant les méta données et les fonctions métiers ?