Discussion :

[Mister Nono]

Salut à tous,

Une appli doit restaurer un fichier(destination) à partir d'une copie d'un autre fichier(source).

Pendant ce traitement de copie de fichier je désire verrouiller l'accès aux 2 fichiers (fichier source et fichier destination).

Comment faire cela ?

Un équivalent sur les objets est : synchronized(monObjet) { ... traitement ... }

Merci.

[thibaut]

Salut,

Si tu es sous java5 tu as FileLock, sinon tu devras programmer le lock toi même, ou créer un fichier .lock pour indiquer que le fichier est vérouillé.

[Mister Nono]

Merci, je vais essayer cela.

[yasinfo]

Salut,

Si tu es sous java5 tu as FileLock, sinon tu devras programmer le lock toi même, ou créer un fichier .lock pour indiquer que le fichier est vérouillé.

Salut,
Ce sujet m'intéresse et je voudrais savoir comment utiliser FileLock.
Merci.

[Kikito]

Salut,
Ce sujet m'intéresse et je voudrais savoir comment utiliser FileLock.
Merci.

Tu récupères une instance de FileChannel via getChannel() de FileInputStream/FileOutputStream.
Tu fais un tryLock() dessus, si y a déja un lock dessus ça renvoie null sinon ca te renvoie une instance de FileLock, à ce moment tu as mis un Lock dessus que tu pourras rendre par release().

[®om]

Le tuto n'est pas fait pour ça, mais il répond à ta question :
http://rom.developpez.com/java-instance-unique/#LII-A-2

[yasinfo]

Salut,
Merci à vous, je vais y jeter un coup d'oeil

[Mister Nono]

Le tuto n'est pas fait pour ça, mais il répond à ta question :
http://rom.developpez.com/java-instance-unique/#LII-A-2

Et oui, je l'avais trouvé aussi, et j'attendais d'être au travail pour essayer cette solution.

Merci encore.

[Mister Nono]

Maintenant que je verrouille les fichiers, je ne peux plus y accéder en écriture :

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
33
34
35
36
37
38
39
40
41
42
43
44
 
public static synchronized void copieFichier(File source, File destination) throws IOException
    {
        RandomAccessFile rafSource = new RandomAccessFile(source, "rw");
        FileChannel fcSource = rafSource.getChannel();
        FileLock verrouSource = fcSource.lock();
 
        RandomAccessFile rafDestination = new RandomAccessFile(destination, "rw");
        FileChannel fcDestination = rafDestination.getChannel();
        FileLock verrouDestination = fcDestination.lock();
 
        FileInputStream sourceFile = null;
        FileOutputStream destinationFile = null;
 
        // creation du fichier
        destination.createNewFile();
 
        // ouverture des flux
        sourceFile = new FileInputStream(source);
        destinationFile = new FileOutputStream(destination);
 
        // lecture par segment de 0.5 Mo
        byte buffer[] = new byte[512 * 1024];
 
        int nbLecture = -1;
 
        while ((nbLecture = sourceFile.read(buffer)) != -1)
        {
            destinationFile.write(buffer, 0, nbLecture);
        }
 
        sourceFile.close();
        destinationFile.close();
 
        verrouSource.release();
        fcSource.close();
        rafSource.close();
 
        verrouDestination.release();
        fcDestination.close();
        rafDestination.close();
 
 
    }

Comment donc, les verrouiller et pouvoir travailler dessus ?

A+

[adiGuba]

Salut,

Si tu es sous java5 tu as FileLock

Juste pour préciser : FileLock est apparut dès Java 1.4 , et son comportement peut varier selon le système (voir la doc.)

a++

[Mister Nono]

Salut,

Si tu es sous java5 tu as FileLock, sinon tu devras programmer le lock toi même, ou créer un fichier .lock pour indiquer que le fichier est vérouillé.

J'utilise Java 5.

[Kikito]

Je n'ai pas testé ton code mais qq remarques comme ça :
- Pour faire de la copie de fichier vers fichier tu as FileChannel.transferTo(...) et FileChannel.transferFrom(...) qui sont extrement rapide.
- Si tu es dans un java.nio utiliser des ByteBuffer va plus vite que des tableaux de bytes.

[Kikito]

Voici un code qui marche sans utiliser de ByteBuffer ou les transfer, juste en corrigeant ce qui ne fonctionnait pas :

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
public static synchronized void copieFichier(File source, File destination) throws IOException
    {
	RandomAccessFile sourceFile = new RandomAccessFile(source, "rw");
	FileChannel fcSource = sourceFile.getChannel();
	FileLock verrouSource = fcSource.lock();
 
	FileOutputStream destinationFile = new FileOutputStream(destination);
	FileChannel fcDestination = destinationFile.getChannel();
	FileLock verrouDestination = fcDestination.lock();
 
        // lecture par segment de 0.5 Mo
        byte buffer[] = new byte[512 * 1024];
 
        int nbLecture = -1;
 
        while ((nbLecture = sourceFile.read(buffer)) != -1)
        {
            destinationFile.write(buffer, 0, nbLecture);
        }
 
        verrouSource.release();
        sourceFile.close();
 
        verrouDestination.release();
        destinationFile.close();
 
    }

Dans ton code, le problème est que tu ouvrais deux fois des flux, si tu ouvres un RandomAcessFile il ne faut pas rouvrir un FileInputStream sur le File mais utiliser le RandomAcessFile pour écrire, c'est lui qui est "propriétaire" du lock pas le thread entier.

[Kikito]

Avec un transfer, plus rapide dans la majorité des cas* et plus simple :

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
public static synchronized void copieFichier(File source, File destination) throws IOException
    {
	RandomAccessFile sourceFile = new RandomAccessFile(source, "rw");
	FileChannel fcSource = sourceFile.getChannel();
	FileLock verrouSource = fcSource.lock();
	FileOutputStream destinationFile = new FileOutputStream(destination);
	FileChannel fcDestination = destinationFile.getChannel();
	FileLock verrouDestination = fcDestination.lock();
 
	fcSource.transferTo(0, fcSource.size(), fcDestination);
 
        verrouSource.release();
        sourceFile.close();
        verrouDestination.release();
        destinationFile.close();
 
    }

*sur des petits fichiers un write avec un petit buffer est légèrement plus rapide

[Mister Nono]

Merci beaucoup Kikito.

Je me doutais bien qu'il fallait passer par le RandomAcessFile mais je ne savais pas comment.

Pour l'idée de passer par un buffer : FAQ Java.

A+

[adiGuba]

Salut,



Pourquoi utiliser un RandomAccessFile ! Et pourquoi ouvrir le fichier source en écriture ("rw") ?
De plus il y a une mauvaise gestion des exceptions : si on a une exception lors de l'ouverture du second fichier (FileNotFound par exemple), le premier fichier ne sera pas fermé et son lock ne sera pas libéré...

On pourrait corriger cela en utilisant 4 blocs try/finally malgré le fait que le code deviennent plus dur à lire :

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
	public static synchronized void copieFichier(File source, File destination)
			throws IOException {
 
		FileInputStream sourceFile = new FileInputStream(source);
		try {
			FileChannel fcSource = sourceFile.getChannel();
			FileLock verrouSource = fcSource.lock();
			try {
				FileOutputStream destinationFile = new FileOutputStream(destination);
				try {
					FileChannel fcDestination = destinationFile.getChannel();
					FileLock verrouDestination = fcDestination.lock();
					try {
 
						fcSource.transferTo(0, fcSource.size(), fcDestination);
 
					} finally {
						verrouDestination.release();
					}
				} finally {
					destinationFile.close();
				}
 
			} finally {
				verrouSource.release();
			}
		} finally {
			sourceFile.close();
		}
	}

Cela peut "masquer" l'exception d'origine mais garantie la fermeture/libération de toutes les ressources...

a++

[Kikito]

Pour faire un lock() sur un fichier tu dois avoir ouvert le fichier en écriture sinon tu vas avoir une NonWritableChannelException, c'est pour cela que j'ouvre le fichier source en "rw", par contre le fichier destination a juste besoin d'écriture donc jj'étais passé par un FileOutputStream.

Pour les flux dans les blocs try tu as biensûr raison, j'avais modifié son code pour qu'il fonctionne mais je n'avais pas pris le temps de bien gérer les exceptions.

[Mister Nono]

Merci adiGuba.

Voici une modification dans ta solution pour éviter trop de try/finally :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
public static synchronized void copieFichier(File source, File destination) throws IOException 
    {
        RandomAccessFile fileSource = null;
        FileChannel fcSource = null;
        FileLock verrouSource = null;
        FileOutputStream fileDestination = null;
        FileChannel fcDestination = null;
        FileLock verrouDestination = null;
 
        try
        {
            fileSource = new RandomAccessFile(source, "rw");
            fcSource = fileSource.getChannel();
            verrouSource = fcSource.lock();
 
            fileDestination = new FileOutputStream(destination);
            fcDestination = fileDestination.getChannel();
            verrouDestination = fcDestination.lock();
 
            fcSource.transferTo(0, fcSource.size(), fcDestination);
        } 
        finally
        {
            if (verrouSource != null)
            {
                verrouSource.release();
            }
 
            if (fcSource != null)
            {
                fcSource.close();
            }
 
            if (fileSource != null)
            {
                fileSource.close();
            }
 
            if (verrouDestination != null)
            {
                verrouDestination.release();
            }
 
            if (fcDestination != null)
            {
                fcDestination.close();
            }
 
            if (fileDestination != null)
            {
                fileDestination.close();
            }
        }
    }

Par contre :

Code :

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

1
2
 
FileInputStream sourceFile = new FileInputStream(source);

... soulève une exception lors de l'appel :

Code :

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

1
2
 
verrouSource = fcSource.lock();

A+

[Kikito]

C'est justement ce que je disais dans mon message précédent, on a posté dans la même minute

Sinon il n'est pas nécessaire de fermer les FileChannel, quand tu fais un close() sur ton RandomAccessFile ou ta stream ça ferme de toute façon les channels ouverts.

[adiGuba]

Voici une modification dans ta solution pour éviter trop de try/finally :

Le problème c'est qu'en cas d'exception à l'intérieur du bloc finally, le reste ne sera pas fermée...


Sinon je pensais qu'il était inutile d'ouvrir le fichier en écriture pour poser un lock, c'est pourquoi je ne comprenais pas pour le RamdomAccessFile


a++