What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
GitHub Actions concurrency is an automatic YAML policy that limits or cancels workflow runs or jobs sharing a concurrency group. It is not a separate “job-level cancellation” feature: job-level concurrency is the same policy applied to one job. Manual cancellation is different—it lets an authorized user stop a particular workflow run from the Actions interface.
What the three controls actually do
| Control | Where it is set or used | What it affects | How it starts |
|---|---|---|---|
| Workflow-level concurrency | At the top level of the workflow YAML | Workflow runs that share a concurrency group | Automatically when matching work enters the group |
| Job-level concurrency | Under jobs.<job_id>.concurrency |
Jobs that share a concurrency group | Automatically when matching work enters the group |
| Manual run cancellation | Actions interface, on a selected run | The selected workflow run and its jobs or steps | An authorized user chooses to cancel that run |
Both YAML scopes use a group and can specify cancellation behavior. The group determines which work interacts; cancel-in-progress determines whether new matching work also stops work already running. Manual cancellation does not depend on a concurrency group. GitHub documents the concurrency syntax and scopes; its manual cancellation guide covers stopping an individual run.
As an Amazon Associate I earn from qualifying purchases.
How concurrency groups and cancellation behave
A concurrency group is a label shared by the workflow runs or jobs you want to constrain. It can be a fixed string or an expression. Use a key that represents the shared resource or work—for example, a workflow and branch for CI, or a deployment target for deployments.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →By default, a group can have one running item and one pending item. When another matching item arrives, it cancels and replaces the existing pending item; that default does not, by itself, cancel the running item. Setting cancel-in-progress: true also cancels the running item. The option applies within the matching group, not to unrelated workflows or jobs.
#1 Best Overall
GitHub’s workflow syntax reference says group names are case-insensitive. It also documents queue: max, which allows up to 100 pending items rather than replacing older pending work. GitHub does not guarantee dispatch order: ordering is based on when an item began waiting, and the order is not guaranteed. queue: max cannot be combined with cancel-in-progress: true. See GitHub’s workflow syntax reference for these queue and group rules.
Choose the scope and group for the work you need to control
Use workflow-level concurrency for competing runs
Put concurrency at the workflow’s top level when matching workflow runs should be constrained as a whole. To keep runs separate by workflow and branch, GitHub’s example uses ${{ github.workflow }}-${{ github.ref }}. Including workflow identity helps avoid unintentionally grouping different workflows that share a ref.
For a workflow triggered by pull requests as well as other events, github.head_ref is only defined for pull-request events. GitHub’s documented fallback is ${{ github.head_ref || github.run_id }}.
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 minuteUse job-level concurrency for a particular job
Put concurrency under jobs.<job_id> when the restriction should apply to that job rather than to the workflow run as a whole. For example, a job that uses a shared resource can have a group representing that resource, while other jobs in the workflow remain outside that group. Whether matching work waits, replaces pending work, or cancels running work still depends on the group and its concurrency settings.
Use a deployment target as the group when deployments share a destination
If the goal is to prevent simultaneous deployments to the same destination, use a group that identifies that shared target. Decide whether a new deployment should replace pending work, cancel the current deployment, or wait in a queue. Concurrency controls serialization; GitHub environments separately provide deployment protections such as approvals, branch restrictions, and access to secrets. GitHub’s deployment documentation explains concurrency and environments.
How to cancel one workflow run manually
- Open the repository on GitHub and select the Actions tab.
- Select the workflow run you want to stop.
- Choose Cancel workflow for that queued or in-progress run.
GitHub requires write access to cancel a run. This is an operator action against the selected run; it does not establish a reusable rule for future runs. Read GitHub’s manual cancellation instructions.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What happens while a run or job is being canceled
Cancellation is not necessarily immediate. GitHub re-evaluates conditions on running jobs. A job whose condition remains true can continue—for example, a job configured with if: always(). A job without an explicit condition is treated as if it had if: success(). GitHub also re-evaluates conditions on unfinished steps.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchFor steps selected for cancellation, the runner first sends an interrupt to the entry process: SIGINT on Linux and macOS, or Ctrl-C on Windows. If it has not exited after 7,500 milliseconds, the runner sends SIGTERM on Linux and macOS, or Ctrl-Break on Windows. After a further 2,500 milliseconds, it kills the process tree if necessary. GitHub documents a five-minute cancellation timeout before the server forcibly terminates jobs and steps still marked for cancellation. These timings and signals are described in GitHub’s workflow cancellation reference.
Because an always() cleanup job or step can continue, cancellation should not be treated as rollback. If a deployment or another step has already changed an external system, the cancellation documentation does not promise to undo that change.
Quick Recap
Which option should you use?
- Prevent duplicate or stale workflow runs: use workflow-level concurrency with a group that identifies the workflow and relevant ref; enable
cancel-in-progressonly if stopping the older running run is acceptable. - Limit contention for one job or shared resource: use job-level concurrency and a group that identifies that resource.
- Let pending matching work accumulate: consider
queue: max, keeping its 100-pending-item limit and incompatibility withcancel-in-progress: truein mind. - Stop one specific run immediately by operator choice: use the Actions interface’s manual cancellation control.
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.
