Discussion :

[denebj]

Bonjour a tous

J'ai une question concernant les opérations multi threads avec lock sur fichier.
J'ai une application web qui effectue des opérations sur des fichiers, pour faire simple.

Par exemple, admettons 3 clients qui se loggent sur mon application.
Client A,B et C

Sur mon application j'ai une liste de liens, chaque lien effectue un traitement sur des fichiers Lecture/Écriture. 1 lien = diffèrent fichiers.

Mon problème : si A,B,C cliquent sur le même lien en même temps, j'ai 3 threads qui lisent/écrivent les mêmes fichiers donc problème.

J’étais parti dans l’idée d'utiliser la synchronisation donc cela fonctionner mais cette solution ne me convient pas car les traitements sont long et si un client clic sur un autre lien, donc autre fichiers, il sera bloque alors que personne n’écrit/lit ces fichiers:

A clique sur 1 => Traitement des fichiers 1
B clique sur 2 => Traitement des fichiers 2 (qui sont indépendants des fichiers 1)
C clique sur 1 => Traitement des fichiers 1

Donc ce dont j'ai besoin, c'est de pouvoir bloquer C puisque A effectue déjà les traitements sur 1 MAIS de pouvoir laisser B effectuer ses traitements sur 2 vu que ces fichiers sont indépendants de 1 et que personne d'autre ne les utilisent.

Et vu que la synchronisation semble bloquer TOUS les threads qui effectuent les mêmes méthodes cela ne convient pas.

J’étais parti sur quelque chose comme cela :
je créer une liste static, avec les fichiers en cours de traitement (A clic sur 1 => 1 est dans la liste etc..). Et si un autre client clic sur 1, il sera déjà dans la liste, donc je le mets en attente.

Peut être y a t-il une autre solution ?

Cordialement

[thelvin]

A priori, il suffit de créer un objet unique pour chaque fichier, et d'utiliser cet objet comme moniteur de lock pour synchroniser l'accès à ce fichier.

Dans le cas de deux fichiers :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private final Object FILE_1_LOCK = new Object();
private final Object FILE_2_LOCK = new Object();
 
public void doSomethingWithFile1() {
  synchronized(FILE_1_LOCK) {
    // faire quelque chose
  }
}
 
public void doSomethingWithFile2() {
  synchronized(FILE_2_LOCK) {
    // faire quelque chose
  }
}

Et généraliser ça si plus de fichiers sont présents.

[denebj]

A priori, il suffit de créer un objet unique pour chaque fichier, et d'utiliser cet objet comme moniteur de lock pour synchroniser l'accès à ce fichier.

Dans le cas de deux fichiers :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private final Object FILE_1_LOCK = new Object();
private final Object FILE_2_LOCK = new Object();
 
public void doSomethingWithFile1() {
  synchronized(FILE_1_LOCK) {
    // faire quelque chose
  }
}
 
public void doSomethingWithFile2() {
  synchronized(FILE_2_LOCK) {
    // faire quelque chose
  }
}

Et généraliser ça si plus de fichiers sont présents.

Hum dans mon cas cela ne semble pas possible, je ne connais pas le nombre total de fichiers, puisqu'ils varient de jour en jour. Il y facilement plusieurs milliers de lien
Et chaque lien travail sur plusieurs fichiers. Par exemple pour le lien 1 => Traitement sur une dizaine de fichier

[thelvin]

Dans ce cas, une Map des fichiers en cours de traitement, avec liste d'attente, se tient.
Il faudra penser à synchroniser l'accès à cette Map.

[denebj]

Cela me semble la meilleure idée, voila a quoi cela ressemble :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
 
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
/**
 * The Class Lock.
 */
public class Lock {
 
	/** The list file in use. */
	static private Map<String,List<String>>	listFileInUse	= new Hashtable<String,List<String>>();
 
	/**
         * Adds the file
         *
         * @param file the file
         * @param clientName the client name
         */
	public synchronized static void addFile(String file, String clientName) {
 
		if(!listFileInUse.containsKey(file))
		{
			List<String> l = new ArrayList<String>();
			l.add(clientName);
			listFileInUse.put(file, l);
		}
		else
		{
			List<String> clientList = listFileInUse.get(file);
			clientList.add(clientName);
			listFileInUse.put(file, clientList);
		}
	}
 
 
	/**
         * Checks if is exist.
         *
         * @param file the file
         * @return true, if checks if is exist
         */
	public static synchronized Boolean isExist(String file) {
 
		List<String> clientList = listFileInUse.get(file);
 
		if (clientList == null)
			return false;
		else
			return true;
	}
 
	/**
         * Delete existing file.
         *
         * @param file the file
         * @param clientName the client name
         * @return the boolean
         */
	public static synchronized Boolean deleteExistingFile(
			String file,  String clientName) {
 
		Boolean flag = false;
		List<String> clientList = listFileInUse.get(file);
 
		for (Iterator<String> it = clientList.iterator(); it.hasNext();) 
		{
			if(it.next().equals(clientName) )
			{
				it.remove();
				flag = true;
				break;
			}
		}
 
		if(listFileInUse.get(file).size() == 0)
			listFileInUse.remove(file);
 
		return flag;
	}
 
 
	/**
         * Gets the next client in wait.
         *
         * @param file the file
         * @return the next client in wait
         */
	public static synchronized String getNextClientInWait(String file)
	{
		List<String> clientList = listFileInUse.get(file);
		return clientList.get(0);	
	}
}

J'ai donc une hastable avec en clef le numéro de mon fichier (qui est unique), et en valeur pour cette clef, les clients qui sont en cours de traitement ou en liste d'attente.
Une fois le traitement termine, j’enlève le client de la liste, et le prochain client dans celle ci pour ce fichier sera débloqué pour son traitement.

Mon problème est le suivant : Comment faire si par exemple un des clients se retrouve dans la liste et décide de fermer son navigateur ou autre ? Il sera toujours dans la liste et je me retrouve avec tout les autres clients bloqués puisque celui si sera a un moment ou un autre au sommet de la liste et les clients en liste d'attente n'auront jamais la main !!!
S'il y a une exception, le client est dégagé de la liste mais dans le cas d'une fermeture du navigateur je n'ai pas vraiment de moyen de l'enlever :/

Que faudrait-il faire ? Un timer ? Je n'ai pas trop d’idée !

Merci !

[sinok]

Ou sinon il existe des vrais locks en java si vous voulez. Qui sont tout de même un poil plus fins que du vieux synchronized des familles...
http://download.oracle.com/javase/tu.../newlocks.html