[Thread]Version multitache d'un programme moins rapide que la version monotache ?!
Bonjour à tous et à toutes :)
j'ai codé un programme qui fragmente un fichier en un nombre donné (par l'utilisateur) de fragments..
l'algorithme utilisé pour fragmenter le fichier est très simpliste : lecture du fichier source octet par octet et écriture dans un fragment après un autre..
voici le code de la classe Fragmenteur :
Code:
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| package fragdefrag;
/*
* Classe qui fragmente un fichier donné en un nombre spécifié de fragments
*/
import java.io.*;
public class Fragmenteur {
/* Constructeur */
public Fragmenteur(File fichier, int nbrFragments) throws FileNotFoundException, IOException {
/* lecture binaire bufférisée depuis le fichier */
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fichier));
/* calculer la taille de chaque fragment */
long tailleFragment = fichier.length() / nbrFragments;
int a;
int compteurFragments = 1;
/* on crée d'abord les nbrFragments - 1 premiers fragments */
while(compteurFragments <= nbrFragments - 1) {
/* écriture binaire bufférisée dans chaque fragment */
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fichier.getAbsolutePath() + "_part_" + compteurFragments));
for(int i=0; i<tailleFragment; i++) {
if((a = bis.read()) != -1) {
bos.write(a);
}
}
bos.close();
compteurFragments++;
}
/* compléter le dernier fragement */
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fichier.getAbsolutePath() + "_part_"+ compteurFragments));
while((a = bis.read()) != -1) {
bos.write(a);
}
bos.close();
bis.close();
genererLog(fichier, nbrFragments);
}
/* méthode privée qui génére un fichier journal et y stocke le nombre de fragments */
private void genererLog(File fichier, int nbrFragments) throws FileNotFoundException, IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter(fichier.getAbsolutePath() + ".log"));
bw.write(nbrFragments + "");
bw.close();
}
} |
comme vous voyez, c'est très évident..
Essayant d'améliorer le programme, j'ai pensé que si chaque fragment était "rempli" par un thread, ça deviendrait peut être plus rapide..
voici le code de la classe Fragmenteur modifiée :
Code:
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| package frag;
/*
* Classe qui fragmente un fichier donné en un nombre spécifié de fragments
*/
import java.io.*;
import java.util.concurrent.CountDownLatch;
public class Fragmenteur {
/* Constructeur */
public Fragmenteur(File file, int nbFragments) throws FileNotFoundException, IOException, InterruptedException {
/* lecture binaire bufférisée depuis le fichier */
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
/* calculer la taille de chaque fragment */
long length = file.length() / nbFragments;
int position;
CountDownLatch countdown = new CountDownLatch(nbFragments - 1);
/* on crée d'abord les nbrFragments - 1 premiers fragments */
for (int i=1 ; i<=nbFragments ; i++) {
/* écriture binaire bufférisée dans chaque fragment */
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getAbsolutePath() + "_part_" + i));
// Chaque fois on calcule la position que le nouveau thread doit se placer pour lire
position = i * (int)length;
Thread fragmentThread = new FragmentThread(bis, bos, position, length, countdown);
fragmentThread.start();
}
/* compléter le dernier fragement */
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getAbsolutePath() + "_part_"+ nbFragments));
int b;
while((b = bis.read()) != -1) {
bos.write(b);
}
bos.close();
/* il faut attendre que les autres thread terminenet avant de fermer le flux de lecture */
countdown.await();
bis.close();
log(file, nbFragments);
}
/* méthode privée qui génére un fichier journal et y stocke le nombre de fragments */
private void log(File file, int nbrFragments) throws FileNotFoundException, IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter(file.getAbsolutePath() + ".log"));
bw.write(nbrFragments + "");
bw.close();
}
} |
et le code de la classe FragmentThread :
Code:
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
33
34
35
36
37
38
39
40
| package frag;
import java.io.*;
import java.util.concurrent.CountDownLatch;
public class FragmentThread extends Thread {
private BufferedInputStream bis;
private BufferedOutputStream bos;
private int startPosition;
private long length;
private CountDownLatch countdown;
/* Constructeur */
public FragmentThread(BufferedInputStream bis, BufferedOutputStream bos, int startPosition, long length, CountDownLatch countdown) {
this.bis = bis;
this.bos = bos;
this.startPosition = startPosition;
this.length = length;
this.countdown = countdown;
}
@Override
public void run() {
try {
int b;
bis.skip(startPosition);
for (int i=0; i<length; i++) {
if ((b = bis.read()) != -1) {
bos.write(b);
}
}
bos.close();
countdown.countDown();
}
catch (IOException e) {
e.printStackTrace();
}
}
} |
:triste: Mauvaise surprise : le temps de Fragmentation a triplé :?
J'arrive pas à déterminer la cause.. merci pour vos éclaircissements..
