Discussion :

[Melvine]

Salut,

J'ai un code qui exécute du sql contenu dans un fichier.
Ce que je fais, c'est que je lis le fichier, je le met dans un string
et ensuite je met le contenu du string dans un tableau.

Je boucle ensuite sur le tableau,
et pour chaque élément du tableau , j'appelle la méthode.

Le truc est que si j'ai 10 éléments dans le tableau,
et que le 1ere met 5 minutes,
il faut attendre que le 1er se termine pour que les autres se suivent.
Je voulais savoir s'il était possible,
de lancer n-fois la méthode en parallèle ?

Merci de votre aide.

[tchize_]

Possible, oui, voulu, non. Si ton fichier contient une série d'opération à faire dans la base de données, il est peu probable d'avoir un résultat correct en faisant ces instructions dans le désordre et dans des transactions distinctes...

Le plus propre est de revoir ces commandes SQL pour qu'elles soient plus performantes . Une instruction SQL qui met 10 minutes à s'exécuter, c'est une instruction sql qui mérite d'être un peu revue

[joel.drigo]

Salut,

Regardes les ExecutorService.

Voir l'article sur l'introduction à la programmation concurrente.

[Melvine]

en faite,
quand je dis instruction SQL,
je parle de requête, l'ordre n'a pas d'importance.
Je peux avoir n requête dans mon fichier,
et il se peut qu'une de ses requêtes mettent 10 minutes voire plus.
Dans la mesure ou je ne serait pas forcément la personne qui va écrire ses requêtes.

L'idée en faite, c'était de pouvoir lancer tout en parallèle,
comme ça les requêtes longues ne pénalise pas les rapides.

[tchize_]

Dans ce cas, comme suggéré, utilise un ExecutorService. Attention cependant! Tu ne peux pas te contenter d'avoir chaque Future exécuter un simple "connection.createStatement". Tu devra aussi garantir que chaque Thread aie sa propre connection. Le plus simple pour ça c'est d'avoir un Connection pool disponible et d'avoir, dans chaque Futula fin.

[Melvine]

C'est pas aussi simple que ça en faite.

J'utilise ceci en faite

Code :

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

1
2
3
ConnexionBase = ConnexionBase(DRIVER,CONNECTION,USER,PASSWD);
preparedStatement = ConnexionBase.prepareStatement(reqSQL);
Resultat rs = preparedStatement.executeQuery();

ce que tu me dis, c'est que chaque thread doit avoir sa propre connexion.

Toute la connexion et l'exécution de la requête est contenu dans une méthode, execReq.

Si dans mon code, chaque fois que je lis une ligne du tableau,
je crée un nouveau execReq :

Code :

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

Creq execReq= new Creq ();

Si j'ai 3 lignes dans le tableau et donc 3 requêtes,
je crée :

Code :

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

1
2
3
4
5
6
Creq execReq1= new Creq ();
execReq1.lanceReq(reqSQL);
Creq execReq2= new Creq ();
execReq2.lanceReq(reqSQL);
Creq execReq3= new Creq ();
execReq3.lanceReq(reqSQL);

Je sais pas si c'est très propre et en y réfléchissant bien,
comme je boucle ,j'imagine que cela revient au même.
Il n'exécutera pas en parallèle.
Dommage qu'on puisse pas lancer en tâche de fond comme sous unix.

[Melvine]

Finalement,
en y réfléchissant bien,
je pense pas que ce soit une bonne solution.
Supposons que 10 grosses requêtes tournent en parallèle,
elles vont faire explosé le tablespace TEMP et elles vont saturées la mémoire.
Autant qu'elles tournent une après l'autre.
Par contre, le système de pool de connexion, sa m'intéresse;

[tchize_]

C'est pour ça qu'on te dit d'utiliser un ExecutorService.

Code :

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

1
2
3
4
5
6
7
8
 
Creq execReq1= new Creq ();
executorService.submit(execReq1);
Creq execReq2= new Creq ();
executorService.submit(execReq2);
Creq execReq3= new Creq ();
executorService.submit(execReq3);
executorService.awaitTerminaison();

Je ne vois pas ce que unix viens faire dans l'histoire

Pour le reste, c'est assez bizarre un Oracle qui ne supporterait pas de faire 10 grosse requêtes en parallèle

[Melvine]

Je faisais allusion à unix car si j'aurai eu à faire cela en ksh.
J'aurai crée un script d'exécution de requête : lance_req.ksh.
Et chaque fois que je boucle,
je fais un fork et je lance mon script en nohup lance_req.ksh &
et comme cela je peux avoir n-script donc n-requête qui tourne en parallèle.