Use GitHub Actions concurrency when you need to prevent overlapping runs on a shared resource or let newer work replace stale pending work. Use queue: max when multiple runs must wait: it retains up to 100 pending jobs or workflow runs per group, but cancels additional arrivals when full. Choose a separate queue architecture when you need retention or processing behavior beyond those bounded workflow-level controls.
What GitHub Actions concurrency does
Concurrency is a workflow- or job-level control for limiting simultaneous execution. Runs that use the same concurrency group do not run at the same time. That makes it a direct fit for protecting a shared deployment environment or resource from concurrent changes; it is not, by itself, a general-purpose durable message queue. See GitHub’s concurrency documentation.
The important distinction is what happens to work that is waiting. By default, GitHub keeps at most one pending run in a group. When another run arrives, it replaces the pending one. That is useful when newer commits make older checks obsolete, but it can discard work that must all complete.
How the waiting and cancellation options differ
| Configuration | Active run | Pending work | Best fit |
|---|---|---|---|
| Default concurrency | Continues running. | At most one pending run; a newer run replaces the existing pending run. | Only the latest waiting work matters. |
cancel-in-progress: true |
Can be canceled when a newer run arrives. | At most one pending run, also subject to replacement. | Obsolete active checks should stop consuming resources. |
queue: max |
Runs one at a time within the group. | Retains up to 100 pending jobs or workflow runs per group; arrivals beyond the limit are canceled. | Multiple runs must wait rather than being replaced. |
GitHub documents the 100-pending limit in its concurrency documentation and multiple-runs queuing guidance. The queue: max option cannot be combined with cancel-in-progress: true. GitHub announced the expanded queue behavior on May 7, 2026, in its changelog.
Recommended Free Tools
#1 Best Overall
Does queue: max guarantee exact FIFO order?
No. GitHub describes runs as FIFO according to when they start waiting on the concurrency group, but warns that start times can vary and ordering is not guaranteed. Dispatch order—such as the order commits were pushed—is therefore not a strict business-order guarantee. If processing order has business consequences, verify that the platform’s documented semantics match that requirement rather than relying on dispatch timing.
Choose a group key that matches the resource
A concurrency group is the boundary for coordination. Runs that share a group can affect one another, including runs from different workflows in the same repository. Group names are case-insensitive. Include workflow identity in the key if you want cancellation or queuing scoped to a particular workflow; omit it when multiple workflows truly need to protect the same resource. GitHub explains these group-key behaviors in its concurrency examples.
For event-dependent values, provide a fallback so a key remains defined for every trigger. GitHub’s example uses github.head_ref for pull requests and falls back to github.run_id when that value is unavailable.
Use concurrency for stale checks and shared deployments
Frequently updated pull requests
For CI checks where only the latest revision matters, key the group to the workflow and branch or reference. Consider cancel-in-progress: true so an obsolete active check can be stopped as well as replacing an obsolete pending check. GitHub’s concepts guidance uses outdated lint runs as an example of work that can be canceled: GitHub Actions concurrency concepts.
A shared deployment environment
For deployments that could alter the same environment, use one shared group for all relevant runs. If every deployment should wait instead of being replaced, configure queue: max and account for the pending-run cap and overflow cancellations.
on:
push:
branches: [main]
concurrency:
group: production-deploy
queue: maxThis follows GitHub’s documented deployment queue pattern. It serializes runs that use this group, but does not guarantee strict dispatch-order execution.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.When a separate queue is the better fit
Consider a separate queue or orchestration design when the requirements exceed GitHub’s bounded run coordination. Examples include retaining more than 100 pending runs per group, application-managed retry policies, dead-letter handling, or strict business-level ordering. These are requirements to evaluate against a candidate system’s documentation; GitHub’s concurrency documentation does not establish general message-broker features, and the official sources cited here do not compare queue vendors.
Quick Recap
- Only need mutual exclusion? Use concurrency; a separate queue is usually unnecessary.
- Can old pending work be discarded? The default replacement behavior may be appropriate; add active-run cancellation only if stopping in-progress work is acceptable.
- Must several runs wait? Use
queue: maxif its 100-pending cap and cancellation on overflow are acceptable. - Need more retention or application-specific processing semantics? Define those requirements and select a queue or orchestrator whose documented behavior satisfies them.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minute
