Question

我有几个继承自ClassA的对象，它有一个抽象方法MethodA。

这些继承对象中的每一个都可以同时允许特定数量的线程进入其MethodA。

catch：线程只能在对象的MethodA中，而没有其他对象的MethodA同时被处理。

我该如何解决这个问题？我正在考虑使用信号量，但不知道该怎么做，因为我无法完全解决问题以获得解决方案。

修改

示例代码（可能包含语法错误:)

public class ClassA
{
  public virtual void MethodA{}
}

public class OneOfMySubclassesOfClassA // there can be multiple instances of each subclass!
{
  public override void MethodA{

  // WHILE any number of threads are in here, THIS MethodA shall be the ONLY MethodA in the entire program to contain threads
  EDIT2: // I mean: ...ONLY MethodA of a subclass (not of a instance of a subclass) in the entire program...
}
}

...and more subclasses...

Answer 1

派生类型在基类中用作类型参数以及静态信号量，以获得在每个子类的所有实例之间共享的一个信号量。然后有一些混乱，以确保只有一种类型是活跃的。快速测试表明这是正常的，但存在问题。

假设例如ClassA1的方法当前正在执行。如果执行此方法的新请求以高频率到达，则可能会发生其他派生类无法执行的情况，因为不断有新线程执行类ClassA1的方法。

internal abstract class ClassA<TDerived> : ClassA
{
    private const Int32 MaximumNumberConcurrentThreads = 3;

    private static readonly Semaphore semaphore = new Semaphore(ClassA<TDerived>.MaximumNumberConcurrentThreads, ClassA<TDerived>.MaximumNumberConcurrentThreads);

    internal void MethodA()
    {
        lock (ClassA.setCurrentlyExcutingTypeLock)
        {
            while (!((ClassA.currentlyExcutingType == null) || (ClassA.currentlyExcutingType == typeof(TDerived))))
            {
                Monitor.Wait(ClassA.setCurrentlyExcutingTypeLock);
            }

            if (ClassA.currentlyExcutingType == null)
            {
                ClassA.currentlyExcutingType = typeof(TDerived);
            }

            ClassA.numberCurrentlyPossiblyExecutingThreads++;

            Monitor.PulseAll(ClassA.setCurrentlyExcutingTypeLock);
        }

        try
        {
            ClassA<TDerived>.semaphore.WaitOne();

            this.MethodACore();
        }
        finally
        {
            ClassA<TDerived>.semaphore.Release();
        }

        lock (ClassA.setCurrentlyExcutingTypeLock)
        {
            ClassA.numberCurrentlyPossiblyExecutingThreads--;

            if (ClassA.numberCurrentlyPossiblyExecutingThreads == 0)
            {
                ClassA.currentlyExcutingType = null;

                Monitor.Pulse(ClassA.setCurrentlyExcutingTypeLock);
            }
        }
    }

    protected abstract void MethodACore();
}

请注意，包装器方法用于调用MethodACore中的实际实现。所有派生类之间共享的所有同步对象都在非泛型基类中。

internal abstract class ClassA
{
    protected static Type currentlyExcutingType = null;

    protected static readonly Object setCurrentlyExcutingTypeLock = new Object();

    protected static Int32 numberCurrentlyPossiblyExecutingThreads = 0;
}

派生类看起来像这样。

internal sealed class ClassA1 : ClassA<ClassA1>
{
    protected override void MethodACore()
    {
        // Do work here.
    }
}

internal sealed class ClassA2 : ClassA<ClassA2>
{
    protected override void MethodACore()
    {
        // Do work here.
    }
}

不幸的是，我现在没有时间更详细地解释其工作方式和原因，但我明天会更新答案。

Answer 2

public abstract class Foo
{
    private static Type lockedType = null;
    private static object key = new object();
    private static ManualResetEvent signal = new ManualResetEvent(false);
    private static int threadsInMethodA = 0;
    private static Semaphore semaphore = new Semaphore(5, 5);//TODO set appropriate number of instances

    public void MethodA()
    {
        lock (key)
        {
            while (lockedType != this.GetType())
            {
                if (lockedType == null)
                {
                    lockedType = this.GetType();
                    //there may be other threads trying to get into the instance we just locked in
                    signal.Set();
                }
                else if (lockedType != this.GetType())
                {
                    signal.WaitOne();
                }
            }

            Interlocked.Increment(ref threadsInMethodA);
        }
        semaphore.WaitOne();

        try
        {
            MethodAImplementation();
        }
        finally
        {
            lock (key)
            {
                semaphore.Release();
                int threads = Interlocked.Decrement(ref threadsInMethodA);
                if (threads == 0)
                {
                    lockedType = null;
                    signal.Reset();
                }
            }
        }
    }

    protected abstract void MethodAImplementation();
}

所以这里有一些关键点。首先，我们有一个静态对象，它表示允许拥有线程的唯一实例。 null表示下一个出现的线程可以放入“他们的”实例。如果另一个实例是“活动”实例，则当前线程等待手动重置事件，直到没有锁定的实例，或者锁定的实例更改为可能是该线程的实例。

计算方法中的线程数以确定何时将锁定的实例设置为null也很重要（设置为null而不跟踪它会让新实例启动而前几个实例正在完成。

在开始和结束时锁定另一个键非常重要。

还要注意，通过这种设置，一种类型可能会饿死其他类型，所以如果这是一个竞争激烈的资源，那么需要注意这一点。

Answer 3

假设您有一个所有相关实例的列表，此代码将锁定所有其他实例，因此只允许在任何给定时间执行一个实例的代码：

void MethodA()
{
     foreach (var obj in objects)
         if (obj != this)
             Monitor.Enter(obj);

try
{
    // do stuff
}
finally
{
        foreach( var obj in objects)
        if (obj != this)
                 Monitor.Exit(obj);
}   
}

所有线程一次只能在一个方法中？

3 个答案: