Are these "halts" temporary (i.e. processing eventually resumes) or permanent?
If temporary, it is likely that the buffer is full. This occurs when you publish at a faster rate than you consume, and the ring buffer starts to fill. Once it is completely full, the next publication attempt blocks until the consumer can free a item from the ring. If the consumer pauses significantly (e.g. a GC) this can happen pretty quickly.
If the halt is permanent, it is possible that you've deadlocked the producer and consumer. This can occur when the consumer thread directly (or indirectly) produces events onto the ring itself, right as the buffer is full.
Imagine a ring buffer that is completely full. The consumer starts processing the oldest item, A. As part of processing A, it decides to publish a different event, B, onto the buffer. However, as the buffer is full, the publication of B will block, meaning thr processing of A is also blocked - the consumer is now deadlocked. The usual publication thread halts as the buffer is completely full, but it will never resume.
Of course, this can happen in ways which aren't as obvious, e.g. if the consumer thread passes something to another thread, which then publishes B back to the ring.
If your architecture does require such a "cycle", it is very important that those "cycle publications" are non-blocking (using the try-publish method). Of course, you need to figure out what to do if publication fails.