I'm using boost::lockfree::spsc_queue in an audio graph to allow audio input samples written from one thread to be read from another. This currently looks like: #include <boost/lockfree/spsc_queue.hpp> class RingBuffer { public: RingBuffer() : mLockFreeQueue( 0 ) {} RingBuffer( size_t size ) : mLockFreeQueue( size + 1 ), mSize( size ) {} ~RingBuffer() {} //! pushes to buffer, overwriting oldest samples void write( const float *samples, size_t count ) { if( count > mSize ) { count = mSize; } size_t numPushed = mLockFreeQueue.push( samples, count ); if( count > numPushed ) { size_t numLeft = count - numPushed; // ???: is there a more efficient way to overwrite? float old; for( int i = 0; i < numLeft; i++ ) { mLockFreeQueue.pop( old ); } numPushed = mLockFreeQueue.push( &samples[numPushed], numLeft ); assert( numPushed == numLeft ); } } size_t read( float *samples, size_t count ) { if( count > mSize ) { count = mSize; } return mLockFreeQueue.pop( samples, count ); } private: boost::lockfree::spsc_queue<float> mLockFreeQueue; size_t mSize; }; If there is not enough space in the write call, I sequentially pop off elements until there is enough. Is there a better way to do this? It seems like there should be a mechanism for just moving the read head forward (atomically) without reading anything, but then I am not sure I completely understand the implications of that on the lockfree model. I'm also not 100% sure this is adhering to the lockfree model, so please inform me if/how it isn't if you know. Thank you for your time, Rich