code:
 public class SingleTaskMutex : IDisposable
{
	public bool Grant();
	public IDisposable Acquire();
}
  
void MasterThread()
{
	using (stMutex = new SingleTaskMutex())
	{
		while (true)
		{
			// do something
			if (stMutex.Grant())
			{
				// do something more if a command was executed
			}
		}
	}
}
  
string SomeSlaveFunction(string value)
{
	using (master.stMutex.Acquire())
	{ 
		// do something
	}
}

code:

Interlocked.Increment(ref owner.waitingSlavesCount);
try
{
	owner.slaveAllowedIn.WaitOne();
}
finally
{
	Interlocked.Decrement(ref owner.waitingSlavesCount);
}

В ответ на:

---

Задача-то тривиальная. Есть распределитель ресурсов, распределяющий ресурс ровно по одной штуке в руки и, вдобавок, сам им пользующийся. Как это сделать? Ну, действительно очень просто формулируется же. Однако я вчера часа четыре трахал себе моск и ничего удовлетворяющего мои запросы не придумал.

---

code:

string SlaveMethod(string param)
{
	string result;
	AutoResetEvent completed = new AutoResetEvent(false);
	lock(master.CommandQueue)
	{
		master.CommandQueue.Enqueue(new Command(completed, () =>
		{
			// here goes all processing...
			result = SomeFunction(param);
			// and some more processing.
		};
	}
	completed.WaitOne();
	return result;
}

void MasterThread
{
	while (!shutDownRequested)
	{
		// do various tasks
		// ...

		Command cmd = null;
		lock (CommandQueue)
		{
			if (CommandQueue.Count > 0)
				cmd = CommandQueue.Dequeue();
		}
		if (null != cmd)
		{
			cmd.Execute();
			// do some more shit after command execution
			//...
			// resume slave thread execution.
			cmd.Completed.Set();
		}
		// And, possibly, do even more shit.
	}
}

code:
namespace TestMasterSlave
{
    class Resource
    { }

    delegate void Action(Resource resource);
    delegate void ActionResult(bool isSuccess);

    class ClientAction
    {
        public Action Action;
        public ActionResult ActionResult;
    }

    class Master
    {
        readonly Queue<ClientAction> clientActions = new Queue<ClientAction>();
        readonly object lockObject = new object();
        readonly Resource resource = new Resource();
        public void RegisterResourceAction(ClientAction clientAction)
        {
            lock(lockObject)
            {
                this.clientActions.Enqueue(clientAction);
            }
        }

        void MainThread()
        {
            while(true)
            {
                ClientAction currentAction = null;
                lock(lockObject)
                {
                    if (clientActions.Count > 0)
                        currentAction = clientActions.Dequeue();
                }
                //Предоставляем ресурс кому надо
                if (currentAction != null)
                {
                    currentAction.Action(resource);
                    //Уведомляем клиента, что мы воспользовались его обработчиком
                    //Передаем статус результата (возможные ошибки и т.д.)
                    currentAction.ActionResult(true);
                }
                //Теперь сами можем использовать ресурс
            }
        }
    }

    class Slave
    {
        public void SlaveFunction(Master master)
        {
            AutoResetEvent completed = new AutoResetEvent(false);
            ClientAction clientAction = new ClientAction();
            clientAction.Action = delegate(Resource resource)
            {
                //Действия с ресурсом
            };
            clientAction.ActionResult = delegate(bool status)
            {
                completed.Set();
            };
            master.RegisterResourceAction(clientAction);
            completed.WaitOne();
        }
    }
}  

code:
namespace TestMasterSlave
{
    class Resource
    { }

    class ResourceUsage
    {
        public readonly DateTime StartUse = DateTime.Now;
        public DateTime? FinishUse = null;
        public bool StartUseResource = false;
        public bool FinishUseResource = false;
    }

    delegate ResourceUsage ResourceAvailable(Resource resource);

    class Master
    {
        readonly Queue<ResourceAvailable> clientRequests = new Queue<ResourceAvailable>();
        readonly object lockObject = new object();
        readonly Resource resource = new Resource();
        
        public void RegisterClientRequest(ResourceAvailable clientRequest)
        {
            lock (lockObject)
            {
                this.clientRequests.Enqueue(clientRequest);
            }
        }


        void MainThread()
        {
            ResourceUsage currentResourceUsage = null;
            while(true)
            {
                if (currentResourceUsage != null)
                {
                    if (currentResourceUsage.FinishUseResource == false)
                    {
                        //проверяем, что возможно ресурс используется неоправданно долго и т.п.
                        if (DateTime.Now - currentResourceUsage.StartUse > TimeSpan.FromDays(365))
                        {
                            //отнимаем ресурс у текущего клиента(нужно подумать как)
                        }
                        Thread.Sleep(TimeSpan.FromSeconds(1));
                        continue;
                    }
                    else
                    {
                        //Сейчас никто не использует ресурс
                        currentResourceUsage = null;
                    }
                }
                //Ресурс сейчас никто не использует - его может использовать сам мастер
                ResourceAvailable resourceAvailable = null;
                lock(lockObject)
                {
              
                    if (clientRequests.Count > 0)
                        resourceAvailable = clientRequests.Dequeue();
                }
                if(resourceAvailable!=null)
                {
                    //Говорим очередному клиенту, что ресурс ему доступен
                    currentResourceUsage = resourceAvailable(resource);
                }
            }
        }
    }

    class Slave
    {
        public void SlaveFunction(Master master)
        {
            AutoResetEvent mayBeginUseResource = new AutoResetEvent(false);
            ResourceUsage resourceUsage = new ResourceUsage();
            Resource resource = null;
            master.RegisterClientRequest(
                delegate(Resource _resource)
                {
                    resource = _resource;
                    mayBeginUseResource.Set();
                    return resourceUsage;
                });
            mayBeginUseResource.WaitOne();
            //Начали использовать ресурс
            try
            {
                resourceUsage.StartUseResource = true;
                //use resource
            }
            finally
            {
                resourceUsage.FinishUseResource = true;
            }
        }
    }
}