How to use async.Future and Promise for asynchronous tasks in Go?

Create a Promise to set a value asynchronously, which completes a Future. Use Future's Get() method to block until the value is available, similar to patterns in languages like Java or JavaScript, as shown in the examples directory.

Is async.SharedMap better than sync.Map for high concurrency?

Async.SharedMap shards data to reduce lock contention, making it more performant under heavy concurrent access. However, sync.Map is simpler and sufficient for many use cases, so benchmark based on your workload.

How does async.Executor compare to using goroutines directly?

Async.Executor manages a worker pool with controlled goroutine spawning and returns Futures for results, offering better resource management and task tracking than manually managing goroutines, but adds overhead for simple tasks.

What's the difference between async.Once and sync.Once in Go?

Async.Once supports error handling by allowing the Do method to return an error, while sync.Once does not. This makes async.Once more flexible for functions that might fail during initialization.

Best practices for using async.CyclicBarrier in concurrent applications?

Use CyclicBarrier to synchronize goroutines at common points; ensure all participating goroutines call Await() and handle reuse for multiple phases. Refer to the test files for implementation examples to avoid deadlocks.

Async package vs other Go concurrency libraries like golang.org/x/sync?

Async focuses on providing additional primitives like maps, futures, and specialized locks, while golang.org/x/sync offers utilities like errgroup and semaphore. Choose based on whether you need advanced data structures or higher-level coordination patterns.

Open-Awesome

async

MITGov0.10.0

A Go package providing synchronization primitives and asynchronous computation utilities beyond the standard library.

Visit Website GitHub

309 stars15 forks0 contributors

What is async?

Async is a Go package that provides a comprehensive set of synchronization primitives and asynchronous computation utilities. It extends the standard library by offering additional concurrency patterns and data structures, such as thread-safe maps, futures, promises, and specialized locks, to simplify building concurrent applications in Go.

Target Audience

Go developers building concurrent applications who need advanced synchronization tools beyond what the standard library offers, such as thread-safe data structures, worker pools, and future/promise patterns.

Value Proposition

Developers choose Async for its idiomatic Go design, performance-focused implementations like sharded maps, and practical utilities that fill gaps in the standard library, making complex concurrency patterns more accessible and manageable.

Overview

Synchronization and asynchronous computation package for Go

Use Cases

Best For

Implementing thread-safe generic maps with sharding for high concurrency
Managing asynchronous task execution with worker pools and futures
Synchronizing goroutines with reusable barriers and context-aware wait groups
Building applications requiring reentrant or priority-based locking mechanisms
Handling lazy or deferred computations with Task and Future/Promise patterns
Extending Go's concurrency toolkit with atomic value storage and error-aware Once

Not Ideal For

Projects relying solely on basic goroutines and channels without advanced synchronization requirements
Distributed systems needing concurrency primitives across multiple machines or processes
Teams prioritizing minimal dependencies and adherence to Go's standard library only

Pros & Cons

Pros

Comprehensive Concurrency Toolkit

Offers a wide range of utilities like ConcurrentMap, ShardedMap, and Future/Promise, as detailed in the README, filling gaps in Go's standard library for complex patterns.

Performance-Optimized Data Structures

Includes ShardedMap which shards data across multiple synchronized maps to reduce lock contention and improve scalability in high-concurrency scenarios.

Idiomatic Go Integration

Designed to complement existing Go patterns, with features like WaitGroupContext adding context support for graceful unblocking, aligning with Go's concurrency philosophy.

Enhanced Error Handling

Provides Once with error handling support, allowing functions to return errors, unlike sync.Once, which improves robustness in asynchronous computations.

Cons

Limited Documentation Depth

The README primarily lists features and points to examples and test files for usage, lacking detailed API documentation that might require digging into source code.

Specialized Primitives Overhead

Utilities like ReentrantLock and PriorityLock are niche and may add unnecessary complexity for typical Go applications that don't require such advanced locking mechanisms.

Ecosystem and Support Concerns

As a third-party package, it has less community adoption and fewer integrations compared to standard library tools, which could impact long-term maintenance and troubleshooting.

Frequently Asked Questions

Related Projects

ants

🐜🐜🐜 ants is the most powerful and reliable pooling solution for Go.

Stars14,468

Forks1,437

Last commit20 days ago

conc

Better structured concurrency for go

Stars10,417

Forks359

Last commit20 days ago

tunny

A goroutine pool for Go

Stars4,033

Forks309

Last commit3 years ago

goworker

goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.

Stars2,847

Forks243

Last commit1 year ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub