Async Concurrency and Deadlock Code Review Report

Role: Principal Systems Architect & Concurrency Engineering Specialist

Context

• Target Microservice: {{service_name}}
• Source Code / Diff Under Review: {{source_code_snippet}}
• Asynchronous & Concurrency Model: {{concurrency_model}}
• Expected Throughput Baseline: {{throughput_target}}
• Database / Connection Driver: {{database_driver}}
• Shared Critical Resources: {{critical_shared_resources}}

Task

Produce a technical concurrency and deadlock audit report for the submitted source code in {{service_name}}, identifying thread safety flaws, resource contention points, and providing verified code remediations.

Method

1. Map all asynchronous execution boundaries and context switching points in {{source_code_snippet}}.
2. Trace mutable state access across concurrent executions using {{concurrency_model}} semantics.
3. Verify lock acquisition order across {{critical_shared_resources}} to uncover circular wait conditions.
4. Analyze connection lifecycle patterns for {{database_driver}} to detect thread starvation or pool exhaustion.
5. Evaluate thread-safety invariants under peak target load of {{throughput_target}}.
6. Pinpoint non-atomic check-then-act sequences and memory visibility hazards.
7. Formulate targeted code modifications with before-and-after diffs to eliminate race conditions.

Constraints

• MUST provide unified code diffs for every critical and high severity issue identified.
• MUST evaluate thread safety strictly against {{concurrency_model}} semantics without adding external runtime dependencies.
• MUST NOT recommend total architectural rewrites or language migrations.
• Explicitly rate all findings as Critical, High, Medium, or Low severity.

Output format

Concurrency Audit Report: {{service_name}}

Executive Summary

• Concurrency Health Score (1-10)
• Core Thread-Safety Verdict

Identified Concurrency Vulnerabilities

Categorized list with: Description, Trigger Scenario under {{throughput_target}}, Failure Mechanism, and Severity Rating.

Remediation Diff & Thread-Safe Architecture

Unified diff showing the exact refactored implementation of {{source_code_snippet}}.

Lock Contention & Resource Utilization Assessment

Specific guidance for managing {{critical_shared_resources}} and {{database_driver}} pool sizing.

Self-review

1. Are all shared mutable resources in {{critical_shared_resources}} accounted for?
2. Does every remediation diff directly solve the identified race condition without introducing latency regressions?
3. Is the deadlock risk analysis verified against circular lock patterns?