Recherche de réponse de this question J'ai trouvé la fonction _locking(). Il dit qu'il Locks or unlocks bytes of a file (en fait je ne peux pas comprendre ce que signifie vraiment cette phrase). Si quelqu'un a l'expérience de l'utilisation de cette fonction, est-il possible d'utiliser la fonction pour résoudre le problème décrit dans la première question?Que fait réellement _locking()?
la page MSDN Citant vous lié:
int _locking(
int fd,
int mode,
long nbytes
);
Le _locking fonction verrouille ou déverrouille nbytes octets du fichier spécifié par fd. Le verrouillage des octets dans un fichier empêche l'accès à ces octets par d'autres processus. Tout le verrouillage ou le déverrouillage commence à la position actuelle du pointeur de fichier et passe à nbytes octets suivants. Il est possible de verrouiller des octets après la fin du fichier.
http://msdn.microsoft.com/en-us/library/8054ew2f(v=vs.71).aspx
Je trouve que cela aide à "régler" le problème Race condition!
La dernière personne à écrire dans un fichier gagne. Dites que vous avez seulement besoin de lire la première moitié d'un fichier sans raison de verrouiller le fichier entier.
Donc, vous prenez la taille du fichier en octets passez-le à cette fonction puis verrouillez-le.
La fonction renvoie un 0 en cas de succès. Une valeur de retour de -1 indique un échec. Dans ce cas, errno est défini sur ce que la page MSDN vous indique.
Pour répondre à votre question
Vous pouvez prendre la taille du fichier, puis le verrouiller, mais vous ne serez en mesure de lire le fichier former. vous le verrouillez en une sorte de mode de lecture seulement.
Dans le wiki de Race condition, il vous donne des exemples de la façon de verrouiller un fichier en obtenant un second processus pour vérifier si un drapeau peut fonctionner dans votre cas.
Il réserve simplement une plage d'un fichier à l'usage exclusif du processus qui acquiert le verrou de fichier. Si un appel de verrouillage réussit, un autre processus qui tente de lire ou d'écrire cette partie du fichier échouera. Cela permet à plusieurs processus d'accéder au même fichier et de le mettre à jour de manière cohérente. C'est un peu comme un mutex pour une plage de fichier. Fondamentalement, il vous permet de mettre à jour des parties d'un fichier de façon atomique, de sorte que tout autre processus de lecture ou d'écriture du fichier verra (ou modifier) soit toute la mise à jour, ou rien de tout cela. Cela s'applique également à la lecture - vous pouvez verrouiller une plage d'un fichier que vous voulez lire pour empêcher qu'un autre processus en modifie une partie pendant que vous êtes en train de le lire.
Mais les processus peuvent toujours accéder à d'autres parties du fichier sans erreur ni délai.
Il ne résoudra pas le problème dans la question à laquelle vous faites référence car _lock() sur; t fonctionne à une granularité de processus. Si le thread A verrouille une plage de fichiers, le thread B peut toujours lire/écrire cette plage dans le même processus.Pour empêcher un autre thread dans le même processus d'accéder à une plage de fichiers, le processus devrait implémenter son propre mécanisme interne pour respecter le fait qu'une plage de fichiers a été verrouillée par un autre thread. Au moins, je ne suis pas au courant de quelque chose qui fait cela dans l'API Win32 (je suppose qu'il pourrait y avoir quelque chose que je ne connais pas).
Cette fonction verrouille le fichier sous forme de toutes les écritures et le rend uniquement lisible à partir de ces octets. l'utilisateur peut facilement ajouter un indicateur qui est globe pour que les threads vérifient avant d'entrer dans le fichier. –
@Dennis: selon les docs, le verrou empêche tout accès - lire ou écrire - à la plage. Je devrais faire des tests pour prouver si c'était le cas. Et cela a aussi du sens, si le processus A change un enregistrement dans le fichier, le processus B ne voudra pas lire l'enregistrement avant la fin de la mise à jour. –
@Dennis: ne pas surestimer à quel point il peut être facile d'ajouter un drapeau. Si vous souhaitez que les contrôles d'accès inter-thread soient granulaires aux plages de fichiers, vous devez conserver une structure de données qui indique les plages verrouillées et des mécanismes de synchronisation (objets de section critiques ou autres) pour gérer l'accès à ces données structure. Ce n'est pas aussi trivial que de vérifier un drapeau. En outre, vous devez ajouter * explicitement * des contrôles d'accès partout où cela est nécessaire. Si vous ne faites pas la vérification à tous les bons moments, le thread B accédera à la plage pendant que le thread A l'a 'verrouillé'. –
Oui, j'ai lu ceci. Mais quand je l'ai essayé pour verrouiller un fichier, alors je ne pouvais pas écrire dans le fichier via ofstream dans le même processus. Alors qu'est-ce que le verrouillage des octets signifie vraiment? –
Ou peut-être que cela ne fonctionne pas correctement pour Win7? –