If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

Regular Reads will block until data is available, but not wait for a full buffer. 

@NullMarked
public class TestLogHandler extends Handler {
  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }

            }
        }
    }

    private fun projectS(num: Int) = if (num == 1) "project" else "projects"

    private inline fun printResult(block: NullawayStatusService.() -> Unit) {
        val delimiter = "=".repeat(72)
        println(delimiter)
        block()
        println(delimiter)
    }

    companion object {
        val SERVICE_NAME = NullawayStatusService::class.qualifiedName!!
    }

    byte[] key = fillByteArray(80, 0xaa);
    String data = "Test Using Larger Than Block-Size Key - Hash Key First";

    checkSha1("aa4ae5e15272d00e95705637ce8a3b55ed402112", key, data);
  }

  public void testRfc2202_hmacSha1_case7() {
    byte[] key = fillByteArray(80, 0xaa);
    String data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";

	return paxHdrs, nil
}

// readHeader reads the next block header and assumes that the underlying reader
// is already aligned to a block boundary. It returns the raw block of the
// header in case further processing is required.
//
// The err will be set to io.EOF only when one of the following occurs:
//   - Exactly 0 bytes are read and EOF is hit.
//   - Exactly 1 block of zeros is read and EOF is hit.

@NullMarked
public class TestLogHandler extends Handler {
  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }

function setupTermynal() {
    document.querySelectorAll(".use-termynal").forEach(node => {
        node.style.display = "block";
        new Termynal(node, {
            lineDelay: 500
        });
    });
    const progressLiteralStart = "---> 100%";
    const promptLiteralStart = "$ ";
    const customPromptLiteralStart = "# ";
    const termynalActivateClass = "termy";
    let termynals = [];

    function createTermynals() {

	data = bytes.TrimSpace(data)

	// Parse all certs in the chain.
	current := data
	for len(current) > 0 {
		var pemBlock *pem.Block
		if pemBlock, current = pem.Decode(current); pemBlock == nil {
			return nil, ErrTLSUnexpectedData(nil).Msgf("Could not read PEM block from file %s", certFile)
		}

		var x509Cert *x509.Certificate
		if x509Cert, err = x509.ParseCertificate(pemBlock.Bytes); err != nil {

	peerS3BucketForceDelete = "force-delete"
)

func healBucketLocal(ctx context.Context, bucket string, opts madmin.HealOpts) (res madmin.HealResultItem, err error) {
	globalLocalDrivesMu.RLock()
	localDrives := cloneDrives(globalLocalDrivesMap)
	globalLocalDrivesMu.RUnlock()

	// Initialize sync waitgroup.
	g := errgroup.WithNErrs(len(localDrives))

	// Disk states slices

@GwtCompatible
@NullMarked
public class TearDownStack implements TearDownAccepter {
  private static final Logger logger = Logger.getLogger(TearDownStack.class.getName());

  @VisibleForTesting final Object lock = new Object();

  @GuardedBy("lock")
  final Deque<TearDown> stack = new ArrayDeque<>();

  private final boolean suppressThrows;

  public TearDownStack() {
    this.suppressThrows = false;
  }