线程安全缓冲区

Question

I'm implementing some kind of buffering mechanism:

private static readonly ConcurrentQueue<ProductDto> ProductBuffer = new ConcurrentQueue<ProductDto>();

private async void On_ProductReceived(object sender, ProductReceivedArgs e)
{
    ProductBuffer.Enqueue(e.Product);

    if (ProductBuffer.Count >= handlerConfig.ProductBufferSize)
    {
        var products = ProductBuffer.ToList();
        ProductBuffer.Clear();

        await SaveProducts(products);
    }
}

And the question is - should I bother to add some kind of lock, to ensure no data is lost (fe some other thread will add product after buffer.ToList() and before buffer.Clear(), hypothetically:), or ConcurrentQueue will handle all the dirty work for me?

Answer 1

You can do it like this:

if (ProductBuffer.Count < handlerConfig.ProductBufferSize)
    return;

var productsToSave = new List<Product>();
Product dequeued = null;
while(ProductBuffer.TryDequeue(out dequeued))
{
    productsToSave.Add(dequeued);
}
SaveProducts(products);

You never Clear the queue. You just keep taking things out until it's empty. Or you could stop taking things out when productsToSave reaches a certain size, process that list, and then start a new one if you don't want to save too many products at once.

This way it doesn't matter if new items are added to the queue. If they're added while you're reading from the queue, they get read too. If they're added just after you stop reading from the queue, they'll be there and get read the next time the queue gets full and you process it.

The point of a ConcurrentQueue is that you can add to it and read from it from multiple threads, with no need for lock .

---

If you were to do this:

    productsToSave = ProductBuffer.ToList();

    ProductBuffer.Clear();

then you would need the lock (which would defeat the purpose.) Presumably you're using a ConcurrentQueue because multiple threads may be adding items to the queue. If that's the case then it is entirely possible that something could go into the queue in between the execution of those two statements. It wouldn't get added to the list, but it would be deleted by Clear . That item would be lost.

Answer 2

This is how I would implement it, I am assuming you do not need to be notified of when the save is finished?

private void On_ProductReceived(object sender, ProductReceivedArgs e)
{
    // Variable to hold potential list of products to save
    List<Products> productsToSave;

    // Lock buffer
    lock(ProductBuffer)
    {
        ProductBuffer.Enqueue(e.Product);

        // If it is under size, return immediately
        if (ProductBuffer.Count < handlerConfig.ProductBufferSize)
            return;

        // Otherwise save products, clear buffer, release lock.
        productsToSave = ProductBuffer.ToList();

        ProductBuffer.Clear();
    }

    // Save Produts, 

    SaveProducts(products);
}

What if you get 1 product, and don't get anything else, will you not want to save this after some timeout?

I would use something like Rx for your use case, especially IObservable<T>.Buffer(count)