BlockingCollection (t) performance

Pendant un certain temps dans mon entreprise, nous avons utilisé une implémentation ObjectPool<T> locale qui permet de bloquer l'accès à son contenu. C'est assez simple: un Queue<T>, un object pour verrouiller, et un AutoResetEvent pour signaler à un "emprunt" de fil lorsqu'un élément est ajouté.

La viande de la classe est vraiment ces deux méthodes:

public T Borrow() {
    lock (_queueLock) {
        if (_queue.Count > 0)
            return _queue.Dequeue();
    }

    _objectAvailableEvent.WaitOne();

    return Borrow();
}

public void Return(T obj) {
    lock (_queueLock) {
        _queue.Enqueue(obj);
    }

    _objectAvailableEvent.Set();
}

Nous avons utilisé ceci et quelques autres classes de collection au lieu de celles fournies par System.Collections.Concurrent parce que nous utilisons.net 3.5, pas 4.0. Mais récemment, nous avons découvert que puisque nous utilisons Extensions réactives , nous avons en fait l'espace de noms Concurrent à notre disposition (dans le système.Le filetage.DLL).

Naturellement, je me suis dit que depuis BlockingCollection<T> est l'une des classes de base de l'espace de noms Concurrent, elle offrirait probablement de meilleures performances que tout ce que moi ou mes coéquipiers avons écrit.

J'ai donc essayé d'écrire une nouvelle implémentation qui fonctionne très simplement:

public T Borrow() {
    return _blockingCollection.Take();
}

public void Return(T obj) {
    _blockingCollection.Add(obj);
}

À ma grande surprise, selon quelques simples tests (emprunt / retour au pool quelques milliers de fois à partir de plusieurs threads), notre implémentation originale Bat significativement BlockingCollection<T> en termes de performance. Ils semblent tous deux fonctionner correctement ; c'est juste que notre implémentation originale semble être beaucoup plus rapide.

Ma question:

1. Pourquoi en serait-il? Est-ce peut-être parce que BlockingCollection<T> offre une plus grande flexibilité (je comprends que cela fonctionne en enveloppant un IProducerConsumerCollection<T>), ce qui introduit nécessairement frais généraux de performance?
2. Est-ce juste une utilisation erronée de la classe BlockingCollection<T>?
3. Si c'est une utilisation appropriée de BlockingCollection<T>, est-ce que je n'utilise pas correctement? Par exemple, est le Take/Add approche trop simpliste, et il y a un moyen beaucoup plus performant d'obtenir la même fonctionnalité?

À moins que quelqu'un n'ait un aperçu à offrir en réponse à cette troisième question, il semble que nous nous en tiendrons à notre implémentation originale pour l'instant.