Buffered Locking Pattern in Go

In Go, a buffered channel allows communication to continue without blocking until its buffer fills up. However, is there a similar pattern for buffering locks that limit resource access to a specific number of clients?

The primitive for managing concurrent access to a resource is the semaphore. A semaphore can be easily implemented using a buffered channel.

Here's an example:

var semaphore = make(chan struct{}, 4) // allow four concurrent users

func f() {
    // Grab the lock. Blocks if 4 other concurrent invocations of f are running.
    semaphore 
In this example, a semaphore with a buffer of size 4 is created using semaphore := make(chan struct{}, 4). The f() function attempts to acquire the lock by sending an empty struct to the channel. If the channel buffer is full (i.e., 4 concurrent instances of f() are already running), the call to semaphore 
When the function finishes its task, it releases the lock by retrieving an empty struct from the channel (-
This pattern provides a convenient way to restrict access to a shared resource to a specific number of concurrent clients, preventing potential resource contention issues.