How to use marusama semaphore for weighted rate limiting in Go?

Use the Acquire method with a context and custom weight to throttle requests based on resource cost. For example, sem.Acquire(ctx, n) where n is the weight, allowing proportional control over concurrent access.

marusama semaphore vs golang.org/x/sync/semaphore: which is better for my project?

Choose marusama for weighted operations and dynamic resizing, as it offers more flexibility. However, golang.org/x/sync/semaphore is part of the Go ecosystem and has zero allocations in benchmarks, making it better for simple, standard use cases.

How to handle timeouts with marusama semaphore?

Pass a context with timeout to the Acquire method, like ctx := context.WithTimeout(context.Background(), time.Second). If the timeout expires, Acquire returns an error, allowing graceful fallback or retry logic.

Is marusama semaphore thread-safe for concurrent goroutines?

Yes, it's designed for concurrency using atomic CAS operations, ensuring safe access from multiple goroutines without additional synchronization, as implied by its benchmark tests.

Can I dynamically adjust pool size with marusama semaphore?

Yes, use the SetLimit method to change the semaphore limit on-the-fly, making it suitable for connection pools or resource managers where capacity needs to scale dynamically.

What are the performance trade-offs of marusama semaphore?

While it excels in speed for weighted and dynamic operations, benchmarks show some allocation overhead compared to channel-based or standard library semaphores, so profile for allocation-heavy workloads.

semaphore — Fast Weighted Go Semaphore

What is semaphore?

Semaphore is a high-performance Go library that implements a semaphore synchronization primitive using compare-and-swap (CAS) operations. It provides a flexible and efficient alternative to channel-based semaphores, enabling fine-grained control over concurrent resource access in Go applications by allowing weighted operations, dynamic resizing, and context support.

Target Audience

Go developers building concurrent applications that require precise control over resource access, such as those implementing rate limiting, connection pooling, or task coordination with variable resource demands.

Value Proposition

Developers choose this library for its performance advantages over channel-based semaphores, as demonstrated in benchmarks, and its advanced features like weighted acquire/release, dynamic limit adjustments, and non-blocking TryAcquire, which are not all available in standard Go approaches.

Fast resizable golang semaphore primitive

Use Cases

Best For

Implementing rate limiting where requests have different resource costs (weighted operations).
Managing concurrent access to a pool of resources with dynamic capacity adjustments.
Building task coordination systems that require cancellable or timeout-based acquisitions via context support.
Optimizing high-performance concurrent applications where low-latency semaphore operations are critical.
Handling scenarios requiring non-blocking semaphore acquisition attempts for responsive system design.
Replacing channel-based semaphores in existing Go codebases for improved flexibility and performance.

Not Ideal For

Projects requiring only simple, unweighted semaphores where Go's built-in channels or sync primitives suffice
Teams building distributed systems needing cross-process or cross-machine synchronization, as this is an in-memory library
Developers prioritizing extensive documentation and large community support over performance optimizations

Pros & Cons

Pros

Weighted Semaphore Operations

Supports acquire and release with custom weights, enabling fine-grained resource control for scenarios like rate limiting with variable costs, as shown in the usage examples.

Context Integration

Integrates with Go's context package for cancellable and timeout-based acquisitions, making it robust for real-world concurrent applications with deadlines or cancellations.

Dynamic Limit Adjustment

Allows resizing the semaphore limit after creation via SetLimit, providing flexibility without reinitialization, a feature highlighted in the README.

Non-blocking TryAcquire

Offers TryAcquire for immediate, non-blocking permit attempts, useful for responsive systems where blocking is undesirable.

High Performance Design

Built using compare-and-swap operations, with benchmarks showing it outperforms many channel-based semaphores, especially under load with lower latency.

Cons

Allocation Overhead in Benchmarks

Benchmarks reveal memory allocations per operation in some tests (e.g., 96 B/op), which could impact performance in allocation-sensitive environments compared to zero-allocation alternatives.

Limited Fairness Guarantees

The README does not address fairness or starvation prevention, which might be a concern for applications requiring strict order in permit acquisition.

Sparse Documentation

Documentation is minimal, lacking detailed examples, error handling guidance, or best practices, which could increase onboarding time for complex use cases.

Frequently Asked Questions

What is semaphore?

Target Audience

Value Proposition

Use Cases

Best For

Implementing rate limiting where requests have different resource costs (weighted operations).
Managing concurrent access to a pool of resources with dynamic capacity adjustments.
Building task coordination systems that require cancellable or timeout-based acquisitions via context support.
Optimizing high-performance concurrent applications where low-latency semaphore operations are critical.
Handling scenarios requiring non-blocking semaphore acquisition attempts for responsive system design.
Replacing channel-based semaphores in existing Go codebases for improved flexibility and performance.

Not Ideal For

Projects requiring only simple, unweighted semaphores where Go's built-in channels or sync primitives suffice
Teams building distributed systems needing cross-process or cross-machine synchronization, as this is an in-memory library
Developers prioritizing extensive documentation and large community support over performance optimizations

Pros & Cons

Pros

Weighted Semaphore Operations

Supports acquire and release with custom weights, enabling fine-grained resource control for scenarios like rate limiting with variable costs, as shown in the usage examples.

Context Integration

Integrates with Go's context package for cancellable and timeout-based acquisitions, making it robust for real-world concurrent applications with deadlines or cancellations.

Dynamic Limit Adjustment

Allows resizing the semaphore limit after creation via SetLimit, providing flexibility without reinitialization, a feature highlighted in the README.

Non-blocking TryAcquire

Offers TryAcquire for immediate, non-blocking permit attempts, useful for responsive systems where blocking is undesirable.

High Performance Design

Built using compare-and-swap operations, with benchmarks showing it outperforms many channel-based semaphores, especially under load with lower latency.

Cons

Allocation Overhead in Benchmarks

Benchmarks reveal memory allocations per operation in some tests (e.g., 96 B/op), which could impact performance in allocation-sensitive environments compared to zero-allocation alternatives.

Limited Fairness Guarantees

The README does not address fairness or starvation prevention, which might be a concern for applications requiring strict order in permit acquisition.

Sparse Documentation

Documentation is minimal, lacking detailed examples, error handling guidance, or best practices, which could increase onboarding time for complex use cases.

Frequently Asked Questions

semaphore

What is semaphore?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?

semaphore

What is semaphore?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?