Question

我已经开发了一个“对象池”，如果不使用Thread.Sleep（）这似乎是不行的，这是我认为的“坏习惯”。

这与我的另一个问题“Is there a standard way of implementing a proprietary connection pool in .net?”有关。对象池背后的想法类似于用于数据库连接的连接池背后的想法。但是，在我的情况下，我使用它来共享标准ASP.NET Web服务（在IIS6中运行）中的有限资源。这意味着许多线程将请求访问此有限资源。池会抛出这些对象（一个“Get”），一旦使用了所有可用的池对象，下一个请求一个的线程就会等待一段时间让这些对象中的一个再次可用（一个线程可以做）一旦对象完成“放置”。如果对象在此设置时间内不可用，则会发生超时错误。

以下是代码：

public class SimpleObjectPool
{
    private const int cMaxGetTimeToWaitInMs = 60000;
    private const int cMaxGetSleepWaitInMs = 10;
    private object fSyncRoot = new object();
    private Queue<object> fQueue = new Queue<object>();

    private SimpleObjectPool()
    {
    }

    private static readonly SimpleObjectPool instance = new SimpleObjectPool();
    public static SimpleObjectPool Instance
    {
        get
        {
            return instance;
        }
    }

    public object Get()
    {
        object aObject = null;
        for (int i = 0; i < (cMaxGetTimeToWaitInMs / cMaxGetSleepWaitInMs); i++)
        {
            lock (fSyncRoot)
            {
                if (fQueue.Count > 0)
                {
                    aObject = fQueue.Dequeue();
                    break;
                }
            }
            System.Threading.Thread.Sleep(cMaxGetSleepWaitInMs);
        }
        if (aObject == null)
            throw new Exception("Timout on waiting for object from pool");
        return aObject;
    }

    public void Put(object aObject)
    {
        lock (fSyncRoot)
        {
            fQueue.Enqueue(aObject);
        }
    }
}

要使用它，可以执行以下操作：

        public void ExampleUse()
        {
            PoolObject lTestObject = (PoolObject)SimpleObjectPool.Instance.Get();
            try
            {
                // Do something...
            }
            finally
            {
                SimpleObjectPool.Instance.Put(lTestObject);
            }
        }

现在我的问题是：我怎么写这个，所以我摆脱了Thread.Sleep（）？

（为什么我要这样做是因为我怀疑它是我在测试中得到的“错误”超时的责任。我的测试应用程序有一个包含3个对象的对象池。它旋转了12个线程，每个线程从池中获取一个对象100次。如果线程从池中获取一个对象，它将持续到2000毫秒，如果没有，则进入下一次迭代。现在逻辑指示9个线程将是在任何时间点等待对象.9 x 2,000 ms是18,000 ms，这是任何线程等待对象所需的最长时间。我的获取超时设置为60,000 ms，因此没有线程应该超时。但是有些做了所以有些事情是错的，我怀疑它是Thread.Sleep）

Answer 1

由于您已在使用lock，请考虑使用Monitor.Wait和Monitor.Pulse

在Get()：

lock (fSyncRoot)
{
   while (fQueue.Count < 1)
     Monitor.Wait(fSyncRoot);

   aObject = fQueue.Dequeue();
}

在Put()：

lock (fSyncRoot)
{
   fQueue.Enqueue(aObject);
   if (fQueue.Count == 1)
         Monitor.Pulse(fSyncRoot);
}

Answer 2

你应该使用信号量。

http://msdn.microsoft.com/en-us/library/system.threading.semaphore.aspx

更新：信号量是多线程编程的基本结构之一。信号量可以以不同的方式使用，但基本思想是当您拥有有限的资源并且许多客户想要使用该资源时，您可以限制在任何给定时间可以访问资源的客户端数量。

下面是一个非常粗略的例子。我没有添加任何错误检查或尝试/终止块，但你应该。

您还可以查看： http://en.wikipedia.org/wiki/Semaphore_(programming)

假设你有10个桶和100个想要使用这些桶的人。我们可以在队列中表示桶。

首先，将所有存储桶添加到队列

for(int i=0;i<10;i++) 
{
    B.Push(new Bucket());
}

现在创建一个信号量来保护您的存储桶队列。创建此信号量时没有触发任何项目，容量为10。

Semaphore s = new Semaphore(0, 10);

所有客户端都应在访问队列之前检查信号量。您可能有100个线程运行下面的线程方法。前10个将通过信号量。所有其他人都会等待。

void MyThread()
{
    while(true)
    {
        // thread will wait until the semaphore is triggered once
        // there are other ways to call this which allow you to pass a timeout
        s.WaitOne();

        // after being triggered once, thread is clear to get an item from the queue
        Bucket b = null;

        // you still need to lock because more than one thread can pass the semaphore at the sam time.
        lock(B_Lock)
        {
            b = B.Pop();
        }

        b.UseBucket();

        // after you finish using the item, add it back to the queue
        // DO NOT keep the queue locked while you are using the item or no other thread will be able to get anything out of it            
        lock(B_Lock)
        {
            B.Push(b);
        }

        // after adding the item back to the queue, trigger the semaphore and allow
        // another thread to enter
        s.Release();
    }
}

没有Thread.Sleep的共享对象池？

2 个答案: