Art von Master/Slave-Schließsystem?

Question

Ich habe keine Ahnung, ob die Sache, die ich machen will, einen Namen hat oder nicht. Das "Master/Slave-Schließsystem" ist leider die beste Formulierung, die ich mir vorstellen konnte.

Nun zum Problem Ich habe ...

Stellen Sie sich die folgende Klasse:

public class Foo 
{ 
    public void Master() 
    { 

    } 

    public void Slave1() 
    { 

    } 

    public void Slave2() 
    { 

    } 
} 

Was ich wünsche ist, dass die Sklaven Methoden (Slave1, Slave2) parallel in einem mehr laufen kann - Threading-Szenario, aber wenn die Master (Master) -Methode aufgerufen wird, muss die Ausführung der Slaves-Methode während der Ausführung blockiert werden. Zusätzlich sollten alle derzeit laufenden Slave-Methoden bis zum Abschluss der Master-Methode ausgeführt werden.

So etwas wie dies (mit Kommentaren):

public class Foo 
{ 
    public void Master() 
    { 
     //block slaves from executing 
     //wait for slaves to finish 

     //do code... 

     //unblock slaves 
    } 

    public void Slave1() 
    { 
     //if blocked by master wait, if not execute 
     //if currently running when entering master method, let it finish 
    } 

    public void Slave2() 
    { 
     //if blocked by master wait, if not execute 
     //if currently running when entering master method, let it finish 
    } 
} 

Ich weiß, ich Sperre für alle drei Methoden verwenden können, aber als die Slave1 Methoden gegenseitig blockieren und das ist nicht das, was ich will.

public class Foo 
{ 
    private readonly object _syncLock = new object(); 

    public void Master() 
    { 
     lock (_syncLock) //blocks Slave1, Slave2 
     { 
      //run code... 
     } 
    } 

    public void Slave1() 
    { 
     lock (_syncLock) //blocks Slave2, Master - dont want that 
     { 
      //run code... 
     } 
    } 

    public void Slave2() 
    { 
     lock (_syncLock) //blocks Slave1, Master - dont want that 
     { 
      //run code... 
     } 
    } 
} 

Wenn möglich, möchte ich die Lösung innerhalb dieser Klasse haben und nicht etwas außerhalb „wenn Sie die Methoden aufrufen, die Art und Weise sie es tun“, können die genannten Verfahren jederzeit in eine ungeordnete Art und Weise Feuer und jede Methode kann mehrere Male laufen.

Answer 1

Wenn ich Sie recht verstehe, wollen Sie

• Exclusive (Write) Sperre setzen auf Master() (kein SlaveN laufen kann)
• Geteilt (Read) Sperre für jede Slave (Sie ein anderes SlaveN laufen kann , aber nicht Master)

Wenn es Ihr Fall ist, bitte haben sie einen Blick auf ReaderWriterLockSlim:

public class Foo { 
    private readonly ReaderWriterLockSlim _syncLock = new ReaderWriterLockSlim(); 

    public void Master() { 
     // Exclusive (write) lock: only Master allowed to run 
     _syncLock.EnterWriteLock(); 

     try { 
     //run code... 
     } 
     finally { 
     _syncLock.ExitWriteLock(); 
     } 
    } 

    public void Slave1() { 
     // Read lock: you can run Slave2 (with another Read lock), but not Master 
     _syncLock.EnterReadLock(); 

     try { 
     //run code... 
     } 
     finally { 
     _syncLock.ExitReadLock(); 
     }   
    } 

    public void Slave2() { 
     // Read lock: you can run Slave1 (with another Read lock), but not Master 
     _syncLock.EnterReadLock(); 

     try { 
     //run code... 
     } 
     finally { 
     _syncLock.ExitReadLock(); 
     }   
    } 
}