panjf2000/ants

★ 14,413GoAudience · developerComplexity · 2/5Setup · easy

Mindmap

mindmap
  root((ants))
    What It Does
      Goroutine pool
      Fixed capacity
      Task recycling
    Key Features
      Panic recovery
      Idle cleanup
      Runtime resize
    Configuration
      Pre-alloc memory
      Queue or reject
      Custom capacity
    Use Cases
      Web servers
      Batch processing
      API call fanout

mindmap root((ants)) What It Does Goroutine pool Fixed capacity Task recycling Key Features Panic recovery Idle cleanup Runtime resize Configuration Pre-alloc memory Queue or reject Custom capacity Use Cases Web servers Batch processing API call fanout

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Limit concurrent goroutines in a Go web server handling uploads or API calls to prevent memory exhaustion

USE CASE 2

Process a large batch of tasks in parallel without creating an unbounded number of goroutines

USE CASE 3

Recover gracefully from a panic in a worker goroutine without crashing the whole program

USE CASE 4

Resize the goroutine pool capacity at runtime to adapt to changing load

Tech stack

Getting it running

Difficulty · easy Time to first run · 5min

In plain English

Ants is a Go library that manages a pool of goroutines. A goroutine is Go's lightweight unit of concurrent execution, similar to a thread in other languages, but much cheaper to create. The problem ants solves is that when a program spawns a very large number of goroutines all at once, memory and CPU usage can spiral out of control. Ants provides a pool with a fixed capacity, recycling workers rather than creating new ones for every task. The library lets you set a maximum number of goroutines that can run at any given time. When you submit a task and the pool is full, the library either queues the task or rejects it immediately, depending on how you configure it. Once a goroutine finishes its task, it goes back into the pool ready to handle the next one. The pool also automatically cleans up goroutines that have been idle too long, keeping memory usage tidy. Key capabilities listed in the README include submitting tasks, checking how many goroutines are currently running, changing the pool's capacity while the program is running, releasing the pool entirely, and rebooting it after release. If a goroutine panics (crashes unexpectedly), ants catches the panic so the whole program does not go down with it. There is also an option to pre-allocate memory for the goroutine queue up front. This is useful when you know you will have a very large pool and want to avoid the overhead of repeatedly allocating memory as the queue grows. Ants works with Go version 1.19 or later and is installed via the standard Go module system. The README includes diagrams illustrating how tasks flow through the pool, and points to additional articles explaining the concepts in more depth.

Copy-paste prompts

Prompt 1

I am using the ants Go library to process 10,000 image resize tasks. Show me how to create a pool with 50 workers, submit all tasks, and wait for them all to finish.

Prompt 2

Write a Go program using ants that downloads 100 URLs concurrently with a pool size of 10 and prints each result as it completes.

Prompt 3

How do I configure ants to pre-allocate memory for the goroutine queue at startup and set a custom panic recovery handler?

Prompt 4

Show me how to dynamically resize an ants goroutine pool from 10 to 50 workers at runtime based on queue depth.

Open on GitHub → Explain another repo

← panjf2000 on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.