ants README

The project's README from github.com/panjf2000/ants. As one markdown file: README.md.

A goroutine pool for Go


English | 中文

📖 Introduction

Library ants implements a goroutine pool with fixed capacity, managing and recycling a massive number of goroutines, allowing developers to limit the number of goroutines in your concurrent programs.

🚀 Features:

💡 How ants works

Flow Diagram

ants-flowchart-en

Activity Diagrams

🧰 How to install

For ants v1

go get -u github.com/panjf2000/ants

For ants v2 (with GO111MODULE=on)

go get -u github.com/panjf2000/ants/v2

🛠 How to use

Check out the examples for basic usage.

Functional options for pool

ants.Optionscontains all optional configurations of the ants pool, which allows you to customize the goroutine pool by invoking option functions to set up each configuration in NewPool/NewPoolWithFunc/NewPoolWithFuncGeneric method.

Check out ants.Options and ants.Option for more details.

Customize pool capacity

ants supports customizing the capacity of the pool. You can call the NewPool method to instantiate a Pool with a given capacity, as follows:

p, _ := ants.NewPool(10000)

Submit tasks

Tasks can be submitted by calling ants.Submit

ants.Submit(func(){})

Tune pool capacity at runtime

You can tune the capacity of ants pool at runtime with ants.Tune:

pool.Tune(1000) // Tune its capacity to 1000
pool.Tune(100000) // Tune its capacity to 100000

Don't worry about the contention problems in this case, the method here is thread-safe (or should be called goroutine-safe).

Pre-malloc goroutine queue in pool

ants allows you to pre-allocate the memory of the goroutine queue in the pool, which may get a performance enhancement under some special certain circumstances such as the scenario that requires a pool with ultra-large capacity, meanwhile, each task in goroutine lasts for a long time, in this case, pre-mallocing will reduce a lot of memory allocation in goroutine queue.

// ants will pre-malloc the whole capacity of pool when calling ants.NewPool.
p, _ := ants.NewPool(100000, ants.WithPreAlloc(true))

Release pool

pool.Release()

or

pool.ReleaseTimeout(time.Second * 3)

Reboot pool

// A pool that has been released can be still used after calling the Reboot().
pool.Reboot()

⚙️ About sequence

All tasks submitted to ants pool will not be guaranteed to be addressed in order, because those tasks scatter among a series of concurrent workers, thus those tasks would be executed concurrently.

👏 Contributors

Please read our Contributing Guidelines before opening a PR and thank you to all the developers who already made contributions to ants!

📄 License

The source code in ants is available under the MIT License.

📚 Relevant Articles

🖥 Use cases

business corporations & open-source organizations

Trusted by the following corporations/organizations.

If you're also using ants in production, please help us enrich this list by opening a pull request.

open-source software

The open-source projects below do concurrent programming with the help of ants.

All use cases:

If you have ants integrated into projects, feel free to open a pull request refreshing this list of use cases.

🔋 JetBrains OS licenses

ants has been being developed with GoLand under the free JetBrains Open Source license(s) granted by JetBrains s.r.o., hence I would like to express my thanks here.

JetBrains logo.

☕️ Buy me a coffee

Please be sure to leave your name, GitHub account, or other social media accounts when you donate by the following means so that I can add it to the list of donors as a token of my appreciation.

Buy me a coffee Patreon OpenCollective

🔋 Sponsorship

DigitalOcean Referral Badge

ants (panjf2000/ants)

Searching Database…

14.5K ·GitHub
What is this?ants is a goroutine pool library for Go: it manages and recycles a massive number of goroutines with a fixed capacity, letting you limit how many run concurrently in your program.
Is this a library I import into my Go code, or a tool I run on its own?It's a library, not a standalone tool — you import it into your own Go program and create and manage pools inside your code.
How do I add it to my project?Install the v2 module with GO111MODULE=on, then create a pool with ants.NewPool(size) and submit work to it via ants.Submit.
Do I need anything besides Go to use it?Just the Go toolchain — it's a single module with no third-party dependencies or services to configure.
Will my tasks run in the order I submit them?No — tasks are scattered across a series of concurrent workers, so ants does not guarantee execution in submission order.
Why use a goroutine pool instead of just launching unlimited goroutines?Spawning a goroutine per task can balloon memory usage; ants recycles workers instead, which keeps memory in check and can even outperform unlimited goroutines in Go.
What happens if one of my tasks panics?ants handles panics gracefully, so a crashing task won't take down your whole program.
Can I resize the pool while my program is running?Yes — call ants.Tune to change the capacity at runtime; the method is goroutine-safe, and you can also release the pool and reboot it later.
What else does the pool offer out of the box?You get APIs for checking the number of running goroutines, periodic purging of overdue goroutines, nonblocking submission, and an optional preallocated ring buffer for ultra-large pools.
Who uses ants in production?Open-source users include gnet, Milvus, TDengine, SiYuan, AdGuard DNS and tRPC-Go, and the README also lists corporations and organizations running it in production.
What are similar projects?conc, fasthttp, asynq, coost, jemalloc, tokio, echo, codon
Creator
panjf2000
Size
1.9 MB
Stars
14.5K
Age
8y
Commits · 90 Days