Discussion :

[loring]

Salut,

Je voudrais créer une “couche” entre le client et la BD afin de pouvoir la modifiée sans avoir à modifier les clients. Cette couche(serveur) contiendrais, entre autre, les fonctions d’accès à la BD.

CLIENT < -- > SERVEUR < -- > BD

Le serveur ne devient-il pas comme un “goulot d’étranglement” (bottle-neck) ?

Exemple de fct)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public SYNCHRONIZED ResultSet getVendeur(int idVendeur){ 
  try{ 
    Statement stm = maConnection.createStatement(); 
    String query = "SELECT * FROM vendeurs WHERE id=” + idVendeur; 
    ResultSet rset = stm.executeQuery(query); 
    return rset; 
  } 
  catch (SQLException ex){ 
    ex.printStackTrace(); 
    return null; 
  } 
}

Le problème est que les fonctions doivent être synchronisées(…je crois), car elles penvent être appellées par plusieurs clients au même moment. Mais si les toutes les fcts sont “synchronized”, si je ne me trompe pas, une seule d’entre elles peut être appellée à la fois? Donc, le “serveur” devient très inefficace étant donné qu’il traite les appels séquentiellement et non de manière concurrente.

Est-ce que je me trompe? Y a t’il une façon de rendre le serveur plus efficace?

Merci.

[Fladnag]

je pense que les bases de données ont deja des mecanismes d'exclusion mutuelle... donc tu n'a pas besoin d'en mettre dans le "serveur" ;o)

Tu peux toujours faire des LOCK (methode de la base de données) sur la table si tu fait des transactions dans une fonction du serveur.

[loring]

D'accord avec toi que les SGBD ont des mécanismes d'exclusion, mais le problème est au niveau de mon "serveur".

CLIENT < -- > SERVEUR < -- > BD

Par exemple, j'ai une fct:

public boolean updateUser( int idUser, String nouveauNom, String nouvelleAdresse, String nouveau noTel ){…}

Si deux clients accèdent à cette fonction au mème moment et que je ne la déclare pas "synchronized"...On ne peut prédire le résultat final dans la BD. Donc, je dois déclarer les fcts du serveurs "synchronized" pour éviter ce genre de problème.

Mais ce qui cause mon problème c'est le fait qu'une seule fct synchronisée peut être appellée sur un même object à la fois. Donc, le “serveur” devient très inefficace étant donné qu’il traite les appels séquentiellement et non de manière concurrente

Voici un exemple, j'ai deux fonctions sur le serveur:

public synchronized void uploaderFichierSurServeur( byte[] fichier ){…}
public synchronized boolean updateUser( int idUser, String nouveauNom ){…}

Je veux que le client 1 puisse uploader un fichier sur le serveur et qu’au même moment le client 2 puisse mettre à jour les infos d’un utilisateur. Deux fcts synchronisées ne peuvent être appellées au même moment(d’après ce que j’ai lu). Donc si un client upload un gros fichier pendant 2 minutes, aucun autre client n’a accès aux autres fcts synchronisées du serveur pendant ce temps. Vrai ou faux ? Est-ce que je me trompe ? Y a-t-il une façon d’éviter ce problème.

Merci.

[Fladnag]

Tu ne te trompe pas sur le fonctionnement de synchronized.

Tu as également la possibilité de faire des exclusions mutuelles plus "fines" si ca t'interesse.

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
public class Server {
    private Object mutex;
 
    public void operation1(...) {
        ...
        synchronized(mutex) {
            // code s'executant en exclusion mutuelle sur le verrou "mutex"
        }
        ...
    }
 
    public void operation2(...) {
        ...
        synchronized(mutex) {
            // code s'executant en exclusion mutuelle sur le verrou "mutex"
        }
        ...
    }
}

Tu peux ainsi déclarer autant de verrous que tu le souhaites, et gerer de maniere plus fine les dépendances de tes fonctions.

Ainsi, si tu as des fonctions travaillant sur des tables differentes de ta BD, tu peux deja mettre des verrous differents, donc autoriser un acces en parallèle a ces fonctions.

Ensuite, tu peux, par ce mecanisme, réduire la portion de code qui s'execute en exclusion mutuelle a une requete par exemple. Pour ton upload de fichier, tu pourrais faire ton upload dans un fichier temporaire, puis, une fois le fichier terminer, faire un copie en local (ou encore mieux, un effacement de l'ancien et un renommage) avec la partie renommange protégée par un synchronized sur un verrou que tu positionne également dans toutes les fonctions accedant a ce fichier.

[ptitjack]

Question bête, c'est pas pour justement traiter ce genre de problèmes que les framework de persistances J2EE ont été développés ? Ce serait pas plus facile d'integrer plutôt une notion de transaction au niveau du serveur plutôt que de tout vouloir synchroniser ? Ce ne serait pas plus intelligent de se diriger vers des framework existant comme Hibernate, EJB, ... pour gérer ce genre de chose histoire de ne pas réinventer la roue ?

Je pose ces questions sans savoir exactement quels sont tes besoins, mais il me semblerais intéressant d'y réfléchir deux secondes histoire de ne pas perdre trop de temps dans ton développement si il existe déjà un framework qui répond à tes besoin...

@+

[loring]

Fladnag...

Si j'utilise l'exclusion mutuelle comme tu me l'as proposé...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class Server { 
    private Object mutex; 
 
    public void operation1(...) { 
        synchronized(mutex) { ... } 
    } 
 
    public void operation2(...) { 
        synchronized(mutex) { ... } 
    } 
}

...Je comprend que deux clients ne pourraient pas accèder le code compris dans "synchronized(mutex){...code...}". Parcontre, deux clients pourraient-il appeller la même fonction, au même moment, avec des paramètres différents...ce qui causerait aussi un problème? Non?

Exemple...le client A appel la fct avec le param 1, obtient le "lock" et ensuite est mis en attente. Pendant ce temps le client B appel la même fct avec le param 2 et attend pour le "lock". Lorsque le client A est remis à l'état "run"...exécute-il la fct avec de mauvais paramètres(ceux du client B)?

Ptitjack...

Je n'ai jamais développé en utilisant le J2EE, mais si tu as une "piste"(explications, docs....) à me donner pour utiliser les suggestions que tu m'as faites je m'y attarderai.

Merci.

[Fladnag]

pas de probleme de parametres, t'inquiete pas, synchronized est bien fait quand meme ;o)

[loring]

Pour faire un petit test j'ai crée cette fct, que j'ai appellé avec 2 threads et des paramètres différents...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public void boucle(String str){
  System.out.println(Thread.currentThread().getName());  
  try{Thread.sleep(2000);}
  catch(InterruptedException ex){}
 
  synchronized(synchro){
  while(true){
    System.out.println(Thread.currentThread().getName() + " " + str);
  }
}

Il semble que tu as raison! Lorsque le thread 1 se "réveille" il exécute la fct avec la bonne string et non celle du thead 2. Pourquoi...je ne sais pas(???), mais ça fonctionne.

Thanks a lot.