Discussion :

[the big ben 5]

Bonjour,

Je voudrais savoir si il est possible d'empecher 2 utilisateurs différents, ayant exécuter le meme programme mais sur des pc différents, d'exectuer des routines en meme temps.

Dans le cas qui me préoccupe, je doit faire un vérification dans ma DB et si c est bon je doit y faire un insert. Mais si 2 personne ont vérifiés en meme temps, il se pourrait que se soit bon pour les 2 et donc qu'ils veuillent inserer en meme temps ce qui me pose problème.

Donc je pensait éventuellement à un bloc synchronise mais je ne sais pas si ca marche pour 2 instances du programme...

D'avance merci

bEn

[glayag]

pour des problemes d'acces a un systeme a entree unique, il existe plusieurs solutions (recherche sur google avec algorithmie).

L'une d'elle est d'utiliser les semaphores.
Le principe est tres simple, tu place un "compteur d'utilisation".
C'est a dire, des que tu vas effectuer ton operation d'insertion, tu met une variable à 1 (ou vrai ou autre chose qui puisse la differencier de son etat "standard"). Quand tu as finis, ton operation, tu la remet dans son etat normal.
Dans ton cas, ca donnerait quelque chose du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
While (MaVariable <> 0) do
  Application.ProcessMessages; //Tu peux meme faire une petite animaltion histoire de dire que c'est en attente
try
  MaVariable:=1;
  VerificationBDD;
  Insertion;
finally
  MaVariable:=0;
end;

[the big ben 5]

Oui ok mais ca ca fonctionne que pour une seule instance du programme non?

Comment fait on communiquer les 2 instance du programme???

[glayag]

Utilise le systeme de semaphore du systeme (Windows en dispose mais je connais pas pour linux).

Cherche les exemple pour n'avoir qu'une seule instance d'un programme avec Delphi, la plupart sont codés avec l'enregistrement d'une semaphore systeme. Ou cherche direct sur la MSDN

En fait, c'est comme une variable interne excepte que c'est gere par le systeme.

[TicTacToe]

ou alors tu utilises les propriétés de verrouillages des BD...

Tu te fais une table dédiée a ca.
Pour le traitement X, il y aura la ligne X dans cette table.

Tu ouvres ta ligne X en édition qd tu commences le traitement (qui que ce soit), tu la cancel qd le traitement est fini.

Si un autre utilisateur tente de faire le traitement, pendant que la ligne X est en édition --> c'est refusé !

et la, pas de problème de nombre de user

Plus simple à mettre en place que les sémaphores en tout cas, et efficace

en gros

Code :

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

1
2
3
4
5
6
7
8
9
 
Se positionner sur LigneX de la table
Si Table pas en edition alors
  try
  Table.Edit
  Traitement
  Finally
  Table.cancel;
  end;

[the big ben 5]

Oui mais je suis sous Delphi 8 et je ne trouve pas les commandes genre CreateSemaphore, ... Que se soit dans l aide ou en tapant directement le code il ne le reconnait pas...

Peut etre via les lock DB je vais peut etre essayer comme ca...

[Andry]

le système de verouillage de TicTacToe est plus simple à mettre en oeuvre mais il y a aussi des danger avec :
- Si l'appli cliente qui a initier le changement se plante alors que le traitement n'est pas terminé jusqu'au bout, tout le monde et bloqué.
- Si le serveur se plante aussi en se moment alors pareil.


A+

[TicTacToe]

Andry a raison dans une certaine mesure

Je ne mets pas un flag sur la ligne (qui serait donc indéfiniment inchangée en cas de plantage), mais juste en édition.

Si c'est un plantage serieux, de toute manière d'autres élements de ta base seront certainement endommagées, et a ce moment la, la priorité ne sera pas ton traitement, mais la réparation de ta base, et donc la fermeture de toutes tes tables (y compris ta table de verrouillage)

Si c'est un plantage léger, ta table aura de très bonne chance d'être "cancélée", et de rendre le verrou. (Perso j'utilise pourtant paradox qui est pas réputée pour être hyper solide, et des lignes qui restent en édition après plantage, j'en ai jamais ou presque).

Si le traitement plante, le finally prend le relai et abandonne l'édition sur la table.

Est-ce plus fiable en cas de plantage avec les sémaphores (c'est vraiment une question, perso je sais pas.. ? ).

[glayag]

Oui mais je suis sous Delphi 8 et je ne trouve pas les commandes genre CreateSemaphore, ... Que se soit dans l aide ou en tapant directement le code il ne le reconnait pas...

Dans l'aide, c'est normal, vu que c'est une fonction de l'API de windows, il faut rechercher dans le SDK.
Dans Delphi, c'est plus etonnant, je viens de rechercher, la fonction est bien dans l'unit "windows" dans D7.

Plus simple à mettre en place que les sémaphores en tout cas, et efficace

La simplicite est toute relative, ca demande un acces en plus a la BDD et ca occupe le proc a chaque fois que tu fais ta requete + gros bug si une erreur survient pendant ce temps: tu n'as pas de gestionnaire d'erreur au niveau de la BDD mais seulement au niveau du prog.

C'est pas que je sois un fervant defenseur de mes idees mais tout de meme, il existe des mecanismes tout pret, pourquoi ne pas les utiliser :
-semaphore
-mutex
-operations atomiques

semaphore :

Code :

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

1
2
3
4
5
 
MySemaphore := CreateSemaphore(Nil, DebutCpt{1}, MaxCpt {1}, nil { ou donne un nom a ta semaphore});
WaitForSingleObject(MySemaphore, {Mettre Infinite ou un temps en milliseconde qui servira de time-out});
//Traitement que tu veux.
ReleaseSemaphore(MySemaphore, 1, nil);

Comme tu peux le voir sur ce premier exemple, c'est tres simple et ca permet meme de mettre un time out en verifiant la sortie de WaitForSingleObject.
Si tu veux que ca marche en inter-process, n'oublie pas de nommer ta semaphore

Au passage, principe de la semaphore (a ce que j'ai compris): creer un compteur avec un valeur initialise, a chaque fois que tu veux acceder a un objet, ca decremente le compteur puis reincremente a la fin.
Ca permet de limiter le nombre d'acces.

mutex :

Code :

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

1
2
3
4
5
6
7
 
MyMutex := OpenMutex(nil, false, 'Nom du mutex');
if MyMutex = nil then
  MyMutex := CreateMutex(nil, false, 'Nom du mutex');
WaitForSingleObject(MyMutex, TpsEnMillisecondes);
//traitement
ReleaseMutex(MyMutex);

Le principe du Mutex est d'avoir 2 positions : une valide et l'autre non.
Je pense que c'est ce qui te convient le mieux.

"Operation atomique":

Code :

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

1
2
3
4
5
 
if GlobalFindAtom('Nom de ton atome') = 0 then
   MyAtom := GlobalAddAtom('Nom de ton atome')
//Traitement
GlobalDeleteAtom('Nom de ton atome');

Bien sur, il est conseille de placer de genre de code dans des blocs try except finally.

[the big ben 5]

Et de quel type est MyMutex alors?

[glayag]

Faut appuyer sur F1 des fois quand meme

The OpenMutex function opens an existing named mutex object.

HANDLE OpenMutex(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCTSTR lpName
);

Return Values
If the function succeeds, the return value is a handle to the mutex object.

If the function fails, the return value is NULL. To get extended error information, call GetLastError.

If a named mutex does not exist, the function returns ERROR_FILE_NOT_FOUND.

[Rayek]

Il y a peut être plus simple en gérant des transactions directement avec la base de données, si, bien sûr la base gère les transactions.

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
 
BeginTrans
try
  Select ...
  Vérification ...
  si c'est ok alors
  debut
    Insert ...
    Commit
  fin
  sinon
    Rollback
Exception
  RollBack
end;

si une demande de transaction est faite pendant la première la seconde devra attendre que la première finisse.
Si une erreur intervient lors d'une transaction , cette derniere est annulée.

Bon tutorial sur les transactions

[the big ben 5]

Oui pour l'instant je l ai fait avec les transactions mais j aimerais qd meme bien réussir aussi avec les Mutex ... Par contre je ne trouve toujours pas la librairie à inclure pour pouvoir faire le OpenMutex!
Sinon, tu n'aurais pas un exemple fonctionnel???

[glayag]

La declaration d'importation est dans l'unit Windows, il suffit donc de l'inclure dans les uses.
Maintenant, j'ai lu que tu avais D8, est ce que D8 ne fait que du .net ??

Sinon, je pense que tu peux importer des fonctions de DLL :

function OpenMutex(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: PChar): THandle; stdcall;
function OpenMutexA(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: PAnsiChar): THandle; stdcall;
function OpenMutexW(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: PWideChar): THandle; stdcall;

dans kernel32.dll