Synchronisation de lecture-écriture croisée croisée Primaire à .NET?

Windows n'inclut pas de verrouillage du lecteur de processus croisé. Une combinaison de sémaphore et de mutex pourrait être utilisée pour construire des systèmes (le mutex est détenu par un écrivain pour un accès exclusif ou par un lecteur qui utilise ensuite le sémaphore pour libérer d'autres lecteurs - c'est-à-dire que les écrivains attendraient uniquement le mutex et les lecteurs .

Toutefois, si la conflit devrait être faible (c'est-à-dire qu'aucun thread contient une serrure pendant de longues), l'exclusion mutuelle peut encore être plus rapide: la complexité supplémentaire de l'écluse du lecteur-Writer submerge tout avantage de permettre aux lecteurs de plusieurs lecteurs. (A Lecteur-Writer Serrure ne sera plus rapide s'il y a beaucoup plus de lecteurs et de serrures sont conservés pour une période significative - mais seul votre profilage peut confirmer cela.)

non. Comme Richard noté ci-dessus, il n'y a pas de tel de la case de la boîte dans .NET. C'est comment la mettre en œuvre à l'aide d'un mutex et d'un sémaphore.

Méthode n ° 1 est décrit dans http://www.jecheng.com/blog/entries/writinganinter-processrea.html , citant: xxx

une alternative serait: < / p>

Verrouillage lu - comme ci-dessus. Écrire le verrouillage comme suit (pseudocode): xxx

Il est à noter qu'une approche plus efficace est possible, comme ici: http://en.wikipedia.org/wiki/readerers-writers_problem#thiters_problem#thiters_problem-writers_problem Recherchez les mots "Cette solution est sous-optimale" dans l'article ci-dessus.

J'ai créé cette classe en fonction de la réponse de Pavel. Je ne l'ai pas encore testé encore, mais j'ai créé une application de WinForms simple pour le tester et jusqu'à présent, cela fonctionne bien.

Veuillez noter que cela utilise un sémaphore, il ne supporte donc pas la réentruisance. xxx

Si vous voulez éviter Starvation écrivain Strong>, vous pourriez envisager un autre algorithme. Je recherche des algorithmes, qui évitent la famine du problème de l'écrivain (par exemple dans cette papier ). L'une des propositions de solution pseudo-code est la suivante: Image pseudo-code . xxx pré>

Malheureusement, CTR code> est un entier, il ne pouvait donc fonctionner que dans les scénarios de interprocession. J'ai décidé de remplacer le comptoir entier avec un Semaphore Compteur Strong> ( ReaderCounter code>) afin qu'il puisse être utilisé pour la communication croisée. Essentiellement, j'ai utilisé serviette (0) code> afin de diminuer strong> et version () code> à augmente strong> le compteur de lecteur. P>

internal class ReaderCounter : IDisposable
{
    internal ReaderCounter(string name, int maxConcurrentRead)
    {
        MaximumCount = maxConcurrentRead + InitialCount;
        myReadCounterSemaphore = new Semaphore(InitialCount, MaximumCount, name);
        myIncomingOperation = new Semaphore(1, 1, name + ".Incoming");
    }

    internal int Increase()
    {
        int counter = RetrieveCurrentCount();

        // Not allowing to exceed maximum count
        if (counter != MaximumCount - 1)
        {
            counter = myReadCounterSemaphore.Release();
        }
        else
        {
            counter++;
        }

        return counter;
    }

    internal int Decrease()
    {
        int counter = RetrieveCurrentCount() - 1;
        myReadCounterSemaphore.WaitOne(0);

        return counter;
    }

    public void Dispose()
    {
        myReadCounterSemaphore?.Dispose();
        myIncomingOperation?.Dispose();

        GC.SuppressFinalize(this);
    }

    internal int MaximumCount { get; private set; }

    private const int InitialCount = 1;
    private readonly Semaphore myReadCounterSemaphore;
    private readonly Semaphore myIncomingOperation;

    private int RetrieveCurrentCount()
    {
        myReadCounterSemaphore.WaitOne(0);
        int counter = myReadCounterSemaphore.Release();
        return counter;
    }
}