Comment verrouiller sur un entier en C#?

J'aime le faire comme ceci

public class Synchronizer {
    private Dictionary<int, object> locks;
    private object myLock;

    public Synchronizer() {
        locks = new Dictionary<int, object>();
        myLock = new object();
    }

    public object this[int index] {
        get {
            lock (myLock) {
                object result;
                if (locks.TryGetValue(index, out result))
                    return result;

                result = new object();
                locks[index] = result;
                return result;
            }
        }
    }
}

Ensuite, de se verrouiller sur un int vous simplement en utilisant la même synchroniseur à chaque fois)

lock (sync[15]) { ... }

Cette classe renvoie le même verrou de l'objet lorsqu'il a reçu le même index à deux reprises. Lorsqu'un nouvel indice vient, c'est de créer un objet, de le retourner, et la stocke dans le dictionnaire pour la prochaine fois.

Il peut être facilement modifié pour fonctionner de manière générique avec tout struct ou type de valeur, ou à être static de sorte que la synchronisation de l'objet n'a pas à être passé autour.

J'ai lu beaucoup de commentaires mentionnant que le verrouillage n'est pas sans danger pour les applications web, mais, à l'exception des batteries de serveurs web, je n'ai pas vu d'explications du pourquoi. Je serais intéressé à entendre les arguments contre elle.

J'ai un besoin similaire, bien que je me suis mise en cache de redimensionner les images sur le disque dur (ce qui est évidemment une action locale, donc une batterie de serveurs web scénario n'est pas un problème).

Ici est une version refaite de ce que @Configurateur posté. Il comprend un couple de fonctionnalités que @Configurateur ne comprend pas:

1. Déverrouillage: s'Assure de la liste de ne pas grandir de taille déraisonnable (nous avons des millions de photos et de nous peut avoir de nombreuses tailles différentes pour chacun).
2. Générique: Permet le verrouillage basé sur différents types de données (comme int ou string).

Voici le code...

///<summary>
///Provides a way to lock a resource based on a value (such as an ID or path).
///</summary>
public class Synchronizer<T>
{
private Dictionary<T, SyncLock> mLocks = new Dictionary<T, SyncLock>();
private object mLock = new object();
///<summary>
///Returns an object that can be used in a lock statement. Ex: lock(MySync.Lock(MyValue)) { ... }
///</summary>
///<param name="value"></param>
///<returns></returns>
public SyncLock Lock(T value)
{
lock (mLock)
{
SyncLock theLock;
if (mLocks.TryGetValue(value, out theLock))
return theLock;
theLock = new SyncLock(value, this);
mLocks.Add(value, theLock);
return theLock;
}
}
///<summary>
///Unlocks the object. Called from Lock.Dispose.
///</summary>
///<param name="theLock"></param>
public void Unlock(SyncLock theLock)
{
mLocks.Remove(theLock.Value);
}
///<summary>
///Represents a lock for the Synchronizer class.
///</summary>
public class SyncLock
: IDisposable
{
///<summary>
///This class should only be instantiated from the Synchronizer class.
///</summary>
///<param name="value"></param>
///<param name="sync"></param>
internal SyncLock(T value, Synchronizer<T> sync)
{
Value = value;
Sync = sync;
}
///<summary>
///Makes sure the lock is removed.
///</summary>
public void Dispose()
{
Sync.Unlock(this);
}
///<summary>
///Gets the value that this lock is based on.
///</summary>
public T Value { get; private set; }
///<summary>
///Gets the synchronizer this lock was created from.
///</summary>
private Synchronizer<T> Sync { get; set; }
}
}

Voici comment vous pouvez l'utiliser...

public static readonly Synchronizer<int> sPostSync = new Synchronizer<int>();
....
using(var theLock = sPostSync.Lock(myID))
lock (theLock)
{
...
}

Cette option repose sur la bonne réponse fournie par le configurateur avec les modifications suivantes:

1. Empêche la taille du dictionnaire de la croissance incontrôlable. Depuis, de nouveaux postes seront obtenir de nouveaux identifiants, votre dictionnaire de serrures va croître indéfiniment. La solution est de mod le id contre un maximum de la taille du dictionnaire. Cela signifie que certains ids ont la même serrure (et d'attendre quand ils n'auraient pas autrement), mais ce sera acceptable pour certains taille du dictionnaire.
2. Utilise ConcurrentDictionary donc il n'est pas nécessaire de séparer les dictionnaire de verrouillage.

Le code:

internal class IdLock
{
internal int LockDictionarySize
{
get { return m_lockDictionarySize; }
}
const int m_lockDictionarySize = 1000;
ConcurrentDictionary<int, object> m_locks = new ConcurrentDictionary<int, object>();
internal object this[ int id ]
{
get
{
object lockObject = new object();
int mapValue = id % m_lockDictionarySize;
lockObject = m_locks.GetOrAdd( mapValue, lockObject );
return lockObject;
}
}
}

Aussi, juste pour être complet, il y a l'alternative de la chaîne de stage: -

1. Mod le id contre le nombre maximum d'internés des chaînes de code vous permettra.
2. Convertir ce modded de la valeur à une chaîne.
3. Concaténer le modded chaîne avec un GUID ou le nom d'espace de noms pour les collisions de nom de la sécurité.
4. Stagiaire cette chaîne.
5. de verrouillage sur la situation des internés de la chaîne.
   Voir cette réponse quelques informations:

Le seul avantage de la chaîne de stage approche est que vous n'avez pas besoin de gérer un dictionnaire. Je préfère le dictionnaire de serrures approche que le stagiaire approche fait beaucoup d'hypothèses sur la façon dont la chaîne de stage œuvres et qu'il continuera à travailler dans ce sens. Il utilise également un stage pour quelque chose, il n'a jamais été question /conçu pour faire.

Coresystem sur codeplex a deux classes pour la synchronisation des threads basée sur les types de valeur, pour les détails, voir http://codestand.feedbook.org/2012/06/lock-on-integer-in-c.html

Vous besoin d'une approche différente de cette.

Rappeler qu'avec un site web, vous n'avez pas réellement un live application en cours d'exécution sur l'autre côté qui répond à ce que fait l'utilisateur.

Vous recommencez en fait une mini-application, qui renvoie à la page web, puis le serveur est fait. Que l'utilisateur finit par l'envoi de certaines données est un sous-produit, pas une garantie.

Donc, vous avez besoin de verrouiller à persister après l'application a retourné à la modération de la page retour à l'animateur, puis relâchez-le lorsque le modérateur est fait.

Et vous avez besoin pour traiter un certain type de l'expiration du délai, si le modérateur ferme son navigateur après l'obtention de la modération de la page de retour, et donc ne communique jamais de retour avec le serveur qu'il/elle est fait avec le processus de modération pour ce post.

Deux en boîte entiers qui ont la même valeur sont complètement indepent objets.
Donc si vous voulez faire cela, votre idée de Dictionnaire serait probablement la voie à suivre. Vous auriez besoin de synchroniser l'accès à un dictionnaire pour assurez-vous que vous êtes toujours obtenir la même instance. Et vous auriez le problème du dictionnaire de croissance en taille.

Vous voulez assurez-vous que la suppression ne se produit pas deux fois?

CREATE PROCEDURE RemovePost( @postID int )
AS
if exists(select postID from Posts where postID = @postID)
BEGIN
DELETE FROM Posts where postID = @postID
-- Do other stuff
END

C'est à peu près la syntaxe SQL server, je ne suis pas familier avec MyISAM. Mais il permet de procédures stockées. Je devine que vous pouvez se moquer d'une procédure similaire.

De toute façon, cela fonctionne pour la majorité des cas. La seule fois où il échouera est que si deux modérateurs soumettre à presque exactement à la même heure, et la exists() la fonction passe sur une requête juste avant de le SUPPRIMER instruction s'exécute sur l'autre demande. Je me ferait un plaisir de les utiliser pour un petit site. Vous pourriez prendre une étape supplémentaire et vérifier que les supprimer réellement supprimé une ligne avant de poursuivre avec le reste, ce qui permettrait de garantir l'atomicité de tout cela.

En essayant de créer une serrure à code, pour ce cas d'utilisation, je considère que très peu pratique. Vous ne perdez rien pour avoir deux modérateurs de la tentative de suppression d'un post, avec un succès, et l'autre n'ayant aucun effet.