Performance and Stability Evaluation of Concurrency Models for I/O-Bound Services in Golang under High-Volume Transaction Load
DOI:
https://doi.org/10.35870/ijsecs.v6i2.7490Keywords:
Concurrency, Golang, Worker Pool, Backpressure, I/O-Bound WorkloadAbstract
Large-scale transaction processing in I/O-bound services can lead to performance bottlenecks and database instability, particularly on resource-constrained servers. An inappropriate concurrency strategy may cause excessive memory consumption and system failure under high workloads. This study compares the efficiency and stability of three concurrency models in Go: Sequential, Unlimited Goroutine, and Worker Pool with a Backpressure mechanism for processing 11 million transaction records against a PostgreSQL database. Testing was conducted in an isolated environment using Docker containers running on a Colima virtual machine configured with 4 CPU cores, 8 GB RAM, and a maximum of 50 database connections. Data were retrieved iteratively using Dynamic Keyset Filtering, while the batch size was calibrated through a preliminary tuning experiment. The results indicate that a batch size of 16,000 provided a balance between I/O efficiency and memory stability. The Unlimited Goroutine model failed to complete the workload due to an out-of-memory (OOM) condition. The Sequential model processed all records in 632 seconds with a throughput of 17,405 transactions per second (Tx/s). The 4-worker Worker Pool achieved the highest throughput at 21,917 Tx/s in 502 seconds, while the 8-worker Worker Pool achieved 19,755 Tx/s in 557 seconds with a 0% error rate and more consistent performance across the tested conditions. Based on the consistency of its performance, the 8-worker Worker Pool was selected as the preferred configuration in this study. These findings indicate that combining a Worker Pool with Backpressure and an appropriately calibrated batch size can improve the performance and stability of large-scale, Go-based transaction processing under the tested conditions.
Downloads
References
Ahmad, A. (2026). Understanding goroutines & the Go scheduler (GMP model). https://blog.arishahmad.in/understanding-goroutines-the-go-scheduler-gmp-model
Dilley, N., & Lange, J. (2019). An empirical study of messaging passing concurrency in Go projects. In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER) (pp. 377–387). IEEE. https://doi.org/10.1109/SANER.2019.8668036
Dinh-Tuan, H. (2025). Unikernels vs. containers: A runtime-level performance comparison for resource-constrained edge workloads. In 2025 8th Conference on Cloud and Internet of Things (CIoT). IEEE.
Doan, S. (2025, May). How worker pools saved our Go services: Lessons from the trenches. Medium. https://medium.com/@sanhdoan/how-worker-pools-saved-out-go-services-lessons-from-the-trenches-e55167a6b353
Hesse, G., Matthies, C., & Uflacker, M. (2020). How fast can we insert? An empirical performance evaluation of Apache Kafka. In 2020 IEEE International Conference on Parallel and Distributed Systems (ICPADS) (pp. 641–648). IEEE.
Kar, S., Rehrmann, R., Mukhopadhyay, A., Alt, B., Ciucu, F., Koeppl, H., Binnig, C., & Rizk, A. (2021). On the throughput optimization in large-scale batch-processing systems. ACM SIGMETRICS Performance Evaluation Review, 48(3), 128–129. https://doi.org/10.1145/3453953.3453982
Kennedy, B. (2018, December). Scheduling in Go: Part III – Concurrency. Ardan Labs. https://www.ardanlabs.com/blog/2018/12/scheduling-in-go-part3.html
Le Noac'h, P., Costan, A., & Bougé, L. (2017). A performance evaluation of Apache Kafka in support of big data streaming applications. In 2017 IEEE International Conference on Big Data. IEEE.
Ling, Y., Mullen, T., & Lin, X. (2000). Analysis of optimal thread pool size. ACM SIGOPS Operating Systems Review, 34(2), 42–55. https://doi.org/10.1145/346152.346320
Malhotra, A. (2025). Concurrency patterns in Golang: Real-world use cases and performance analysis. Journal of Computing and Software Technologies, 5(1), 1–14. https://al-kindipublishers.org/index.php/jcsts/article/view/10083
Matteussi, K. J., dos Anjos, J. C. S., Leithardt, V. R. Q., & Geyer, C. F. R. (2022). Performance evaluation analysis of Spark Streaming backpressure for data-intensive pipelines. Sensors, 22(13), 4756. https://doi.org/10.3390/s22134756
Nguyen, T. (2024, July). A comprehensive guide to concurrency in Golang. Relia Software. https://reliasoftware.com/blog/concurrency-in-golang
Reza, D., & Supatmi, S. (2023). Concurrency performance analysis on MySQL RDBMS in virtual machine environment. In 2023 9th International Conference on Science and Technology (ICSPIS) (pp. 1–7). IEEE.
Sharma, P. (2025, December). Designing high throughput Go services for continuous database change streams. DEV Community. https://dev.to/sharmaprash/golang-optimizations-for-high-volume-services-dij
Surwase, R. K. (2024, April). Efficient concurrency in Go: A deep dive into the worker pool pattern for batch processing. Medium. https://rksurwase.medium.com/efficient-concurrency-in-go-a-deep-dive-into-the-worker-pool-pattern-for-batch-processing-73cac5a5bdca
Wu, M., et al. (2020). Platinum: A CPU-efficient concurrent garbage collector for tail-reduction of interactive services. In 2020 USENIX Annual Technical Conference (USENIX ATC) (pp. 159–172).
Yıldırım, H. (2024, February). CPU vs I/O bound benchmarking in Go. Medium. https://medium.com/@halilylm/cpu-vs-i-o-bound-benchmarbing-in-go-fcd4f053694e
Zhao, J., Zhou, X., Chang, S.-Y., & Xu, C. (2023). Let it go: Relieving garbage collection pain for latency critical applications in Golang. In Proceedings of the 32nd International Symposium on High-Performance Parallel and Distributed Computing (HPDC '23) (pp. 169–180).
Downloads
Published
Issue
Section
Categories
License
Copyright (c) 2026 Salsabila Yunita Sari, Felix David
This work is licensed under a Creative Commons Attribution 4.0 International License.
Authors who publish with this journal agree to the following terms:
1. Copyright Retention and Open Access License
Authors retain copyright of their work and grant the journal non-exclusive right of first publication under the Creative Commons Attribution 4.0 International License (CC BY 4.0).
This license allows unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
2. Rights Granted Under CC BY 4.0
Under this license, readers are free to:
- Share — copy and redistribute the material in any medium or format
- Adapt — remix, transform, and build upon the material for any purpose, including commercial use
- No additional restrictions — the licensor cannot revoke these freedoms as long as license terms are followed
3. Attribution Requirements
All uses must include:
- Proper citation of the original work
- Link to the Creative Commons license
- Indication if changes were made to the original work
- No suggestion that the licensor endorses the user or their use
4. Additional Distribution Rights
Authors may:
- Deposit the published version in institutional repositories
- Share through academic social networks
- Include in books, monographs, or other publications
- Post on personal or institutional websites
Requirement: All additional distributions must maintain the CC BY 4.0 license and proper attribution.
5. Self-Archiving and Pre-Print Sharing
Authors are encouraged to:
- Share pre-prints and post-prints online
- Deposit in subject-specific repositories (e.g., arXiv, bioRxiv)
- Engage in scholarly communication throughout the publication process
6. Open Access Commitment
This journal provides immediate open access to all content, supporting the global exchange of knowledge without financial, legal, or technical barriers.
