Mutual exclusion i C#

Readers/Writers er et klassisk problem inden for datalogi - prøv at kigge på http://www.codeproject.com/threads/mutexrw.asp

Fint eksempel, men leder mere efter en C#/.Net implementation.

Har kigget lidt på .NET Mutex klassen, men kan ikke lige se hvordan det løser mit problem

Man kan ikke locke primitives, men er i++ og i-- thread safe?

Ellers kunne jeg måske boxe en primitive og så tælle den op når en ny reader starter og ned når den er færdig. Men det er jo ikke en hel smuk løsning og vil nok resultere i en masse overhead :/

i++ og i-- er ikke tråd-sikre. Man bør bruge metoderneIncrement() og Decrement() på System.Trhreading.Interlocked

Tror i følgende vil virke?
--------------------------
private System.Int32 readers = new System.Int32(0);

private System.Threading.Mutex writeLock = new System.Threading.Mutex();

private BeginMutexRead()
{
    // Make sure we wait until write has finished
    writeLock.WaitOne(writeLock);
    // Make sure nobody else is changing the boxed read conter
    System.Threading.Monitor.Monitor(readers);
    // Add a reader
    readers++;
    if (readers == 1)
    {
        // Require mutex write lock
        writeLock.WaitOne(writeLock);
    }
    System.Threading.Monitor.Exit(readers);
    writeLock.ReleaseMutex(writeLock);
}

private EndMutexRead()
{
    // Make sure we wait until write has finished
    writeLock.WaitOne(writeLock);
    System.Threading.Monitor.Monitor(readers);
    readers--;
    if (readers == 0)
    {
        // Release mutex write lock
        writeLock.ReleaseMutex(writeLock);
    }
    System.Threading.Monitor.Exit(readers);
    writeLock.ReleaseMutex(writeLock);
}

private BeginMutexWrite()
{
    // Make sure we wait until read and write has finished
    writeLock.WaitOne(writeLock);
}

private EndMutexWrite()
{
    // Allow other threads to read and write
    writeLock.ReleaseMutex(writeLock);
}
--------------------------

Det her kode (som jeg har porteret fra noget Java kod ejeg havde liggende)
virker ihvertfald:

using System;
using System.Threading;

namespace E1
{
    public class MultiSemaphore {
        public const int EXCLUSIVE = 1;
        public const int SHARED = 2;
        private int nouser;
        private int mode;

        public MultiSemaphore() {
            nouser = 0;
        }

        public void Get(int mode) {
            lock(this)
            {
                while ((this.mode == EXCLUSIVE || mode == EXCLUSIVE) && nouser > 0) {
                    Monitor.Wait(this);
                }
                nouser++;
                this.mode = mode;
            }
        }

        public void Release() {
            lock(this)
            {
                nouser--;
                Monitor.PulseAll(this);
            }
        }
    }

    class MyThread {
        private MultiSemaphore sem;
        private bool excl;

        public MyThread(MultiSemaphore sem, bool excl) {
            this.sem = sem;
            this.excl = excl;
        }

        public void Run() {
            sem.Get(excl ? MultiSemaphore.EXCLUSIVE : MultiSemaphore.SHARED);
            Thread.Sleep(3000);
            sem.Release();
        }
    }
    class MainClass
    {
        private static void Test(bool excl) {
            long start = DateTime.Now.Ticks;
            MultiSemaphore sem = new MultiSemaphore();
            Thread[] t = new Thread[10];
            for (int i = 0; i < t.Length; i++) {
                t[i] = new Thread(new ThreadStart((new MyThread(sem, excl)).Run));
            }
            for (int i = 0; i < t.Length; i++) {
                t[i].Start();
            }
            Thread.Sleep(1000);
            for (int i = 0; i < t.Length; i++) {
                t[i].Join();
            }
            long end = DateTime.Now.Ticks;
            Console.WriteLine((excl ? "Exclusive" : "Shared") + " time = " + (end - start));
        }
        public static void Main(string[] args)
        {
            Test(true);
            Test(false);
        }
    }
}

Det ser ud til at virke, men er det ikke noget med at Semaphores kan medføre deadlocks?

Anyway smid et svar ;)

svar

Ovenstående kan godt lave en deadlock.

tråd 1 laver eksklusiv lock på A
tråd 2 laver eksklusiv lock på B
tråd 1 forsøger at lave eksklusiv lock på B
tråd 2 forsøger at lave eksklusiv lock på A
og så sker der ikke ret meget

Den gængse løsning er at have en konvention om i hvilken rækkefølge locks
skal udtages.

I ovenstående hvis alle tråde skal tage lock på A før de tager på B så kan
der ikke opstå en deadlock.